diff --git a/src/checkqueue.h b/src/checkqueue.h
index 037023ee3a2..5258d7113e6 100644
--- a/src/checkqueue.h
+++ b/src/checkqueue.h
@@ -5,9 +5,9 @@
 #ifndef BITCOIN_CHECKQUEUE_H
 #define BITCOIN_CHECKQUEUE_H
 
-#include <logging.h>
 #include <sync.h>
 #include <tinyformat.h>
+#include <util/log.h>
 #include <util/threadnames.h>
 
 #include <algorithm>
diff --git a/src/coins.cpp b/src/coins.cpp
index a3bc369de30..fc33c521617 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -5,9 +5,9 @@
 #include <coins.h>
 
 #include <consensus/consensus.h>
-#include <logging.h>
 #include <random.h>
 #include <uint256.h>
+#include <util/log.h>
 #include <util/trace.h>
 
 TRACEPOINT_SEMAPHORE(utxocache, add);
diff --git a/src/dbwrapper.cpp b/src/dbwrapper.cpp
index b3f08cb20d6..eb222078b5e 100644
--- a/src/dbwrapper.cpp
+++ b/src/dbwrapper.cpp
@@ -4,21 +4,6 @@
 
 #include <dbwrapper.h>
 
-#include <logging.h>
-#include <random.h>
-#include <serialize.h>
-#include <span.h>
-#include <streams.h>
-#include <util/fs.h>
-#include <util/fs_helpers.h>
-#include <util/obfuscation.h>
-#include <util/strencodings.h>
-
-#include <algorithm>
-#include <cassert>
-#include <cstdarg>
-#include <cstdint>
-#include <cstdio>
 #include <leveldb/cache.h>
 #include <leveldb/db.h>
 #include <leveldb/env.h>
@@ -29,6 +14,22 @@
 #include <leveldb/slice.h>
 #include <leveldb/status.h>
 #include <leveldb/write_batch.h>
+#include <logging.h>
+#include <random.h>
+#include <serialize.h>
+#include <span.h>
+#include <streams.h>
+#include <util/fs.h>
+#include <util/fs_helpers.h>
+#include <util/log.h>
+#include <util/obfuscation.h>
+#include <util/strencodings.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cstdarg>
+#include <cstdint>
+#include <cstdio>
 #include <memory>
 #include <optional>
 #include <utility>
@@ -57,7 +58,7 @@ public:
     // This code is adapted from posix_logger.h, which is why it is using vsprintf.
     // Please do not do this in normal code
     void Logv(const char * format, va_list ap) override {
-            if (!LogAcceptCategory(BCLog::LEVELDB, BCLog::Level::Debug)) {
+            if (!LogAcceptCategory(BCLog::LEVELDB, util::log::Level::Debug)) {
                 return;
             }
             char buffer[500];
@@ -276,7 +277,7 @@ CDBWrapper::~CDBWrapper()
 
 void CDBWrapper::WriteBatch(CDBBatch& batch, bool fSync)
 {
-    const bool log_memory = LogAcceptCategory(BCLog::LEVELDB, BCLog::Level::Debug);
+    const bool log_memory = LogAcceptCategory(BCLog::LEVELDB, util::log::Level::Debug);
     double mem_before = 0;
     if (log_memory) {
         mem_before = DynamicMemoryUsage() / 1024.0 / 1024;
diff --git a/src/flatfile.cpp b/src/flatfile.cpp
index 140217b0603..056fb9c1f92 100644
--- a/src/flatfile.cpp
+++ b/src/flatfile.cpp
@@ -3,12 +3,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <stdexcept>
-
 #include <flatfile.h>
-#include <logging.h>
+
 #include <tinyformat.h>
 #include <util/fs_helpers.h>
+#include <util/log.h>
+
+#include <stdexcept>
 
 FlatFileSeq::FlatFileSeq(fs::path dir, const char* prefix, size_t chunk_size) :
     m_dir(std::move(dir)),
diff --git a/src/index/base.cpp b/src/index/base.cpp
index 7f77d13a574..fba2f4f6c10 100644
--- a/src/index/base.cpp
+++ b/src/index/base.cpp
@@ -10,7 +10,6 @@
 #include <interfaces/chain.h>
 #include <interfaces/types.h>
 #include <kernel/types.h>
-#include <logging.h>
 #include <node/abort.h>
 #include <node/blockstorage.h>
 #include <node/context.h>
@@ -22,6 +21,7 @@
 #include <uint256.h>
 #include <undo.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <util/string.h>
 #include <util/thread.h>
 #include <util/threadinterrupt.h>
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
index caf6d592e7e..67fa1fab318 100644
--- a/src/index/blockfilterindex.cpp
+++ b/src/index/blockfilterindex.cpp
@@ -14,7 +14,6 @@
 #include <index/db_key.h>
 #include <interfaces/chain.h>
 #include <interfaces/types.h>
-#include <logging.h>
 #include <serialize.h>
 #include <streams.h>
 #include <sync.h>
@@ -22,6 +21,7 @@
 #include <util/check.h>
 #include <util/fs.h>
 #include <util/hasher.h>
+#include <util/log.h>
 #include <util/syserror.h>
 
 #include <cerrno>
diff --git a/src/index/coinstatsindex.cpp b/src/index/coinstatsindex.cpp
index 6be3db9a897..319ffcadc63 100644
--- a/src/index/coinstatsindex.cpp
+++ b/src/index/coinstatsindex.cpp
@@ -17,7 +17,6 @@
 #include <interfaces/chain.h>
 #include <interfaces/types.h>
 #include <kernel/coinstats.h>
-#include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -26,6 +25,7 @@
 #include <undo.h>
 #include <util/check.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <validation.h>
 
 #include <compare>
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
index d7d8cb56652..d0e88021325 100644
--- a/src/index/txindex.cpp
+++ b/src/index/txindex.cpp
@@ -10,7 +10,6 @@
 #include <index/base.h>
 #include <index/disktxpos.h>
 #include <interfaces/chain.h>
-#include <logging.h>
 #include <node/blockstorage.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
@@ -18,6 +17,7 @@
 #include <streams.h>
 #include <uint256.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <validation.h>
 
 #include <cassert>
diff --git a/src/kernel/chainparams.cpp b/src/kernel/chainparams.cpp
index 16ebffb9a98..79cf2ff7023 100644
--- a/src/kernel/chainparams.cpp
+++ b/src/kernel/chainparams.cpp
@@ -12,13 +12,13 @@
 #include <crypto/hex_base.h>
 #include <hash.h>
 #include <kernel/messagestartchars.h>
-#include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 #include <uint256.h>
 #include <util/chaintype.h>
+#include <util/log.h>
 #include <util/strencodings.h>
 
 #include <algorithm>
diff --git a/src/kernel/coinstats.cpp b/src/kernel/coinstats.cpp
index 13c0bee836f..d287ec4be6e 100644
--- a/src/kernel/coinstats.cpp
+++ b/src/kernel/coinstats.cpp
@@ -8,7 +8,6 @@
 #include <coins.h>
 #include <crypto/muhash.h>
 #include <hash.h>
-#include <logging.h>
 #include <node/blockstorage.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
@@ -17,6 +16,7 @@
 #include <sync.h>
 #include <uint256.h>
 #include <util/check.h>
+#include <util/log.h>
 #include <util/overflow.h>
 #include <validation.h>
 
diff --git a/src/kernel/context.cpp b/src/kernel/context.cpp
index e74f29cbc1a..9148bf57331 100644
--- a/src/kernel/context.cpp
+++ b/src/kernel/context.cpp
@@ -5,8 +5,8 @@
 #include <kernel/context.h>
 
 #include <crypto/sha256.h>
-#include <logging.h>
 #include <random.h>
+#include <util/log.h>
 
 #include <mutex>
 #include <string>
diff --git a/src/logging.cpp b/src/logging.cpp
index 1c3e30e9807..df6946d6611 100644
--- a/src/logging.cpp
+++ b/src/logging.cpp
@@ -602,3 +602,16 @@ bool BCLog::Logger::SetCategoryLogLevel(std::string_view category_str, std::stri
     m_category_log_levels[flag] = level.value();
     return true;
 }
+
+bool util::log::ShouldLog(Category category, Level level)
+{
+    return LogInstance().WillLogCategoryLevel(static_cast<BCLog::LogFlags>(category), level);
+}
+
+void util::log::Log(util::log::Entry entry)
+{
+    BCLog::Logger& logger{LogInstance()};
+    if (logger.Enabled()) {
+        logger.LogPrintStr(std::move(entry.message), std::move(entry.source_loc), static_cast<BCLog::LogFlags>(entry.category), entry.level, entry.should_ratelimit);
+    }
+}
diff --git a/src/logging.h b/src/logging.h
index 2ab21071a06..e21495015b6 100644
--- a/src/logging.h
+++ b/src/logging.h
@@ -7,10 +7,10 @@
 #define BITCOIN_LOGGING_H
 
 #include <crypto/siphash.h>
+#include <logging/categories.h> // IWYU pragma: export
 #include <threadsafety.h>
-#include <tinyformat.h>
-#include <util/check.h>
 #include <util/fs.h>
+#include <util/log.h> // IWYU pragma: export
 #include <util/string.h>
 #include <util/time.h>
 
@@ -20,11 +20,8 @@
 #include <functional>
 #include <list>
 #include <memory>
-#include <mutex>
-#include <source_location>
 #include <string>
 #include <unordered_map>
-#include <unordered_set>
 #include <vector>
 
 static const bool DEFAULT_LOGTIMEMICROS = false;
@@ -37,26 +34,6 @@ extern const char * const DEFAULT_DEBUGLOGFILE;
 
 extern bool fLogIPs;
 
-/// Like std::source_location, but allowing to override the function name.
-class SourceLocation
-{
-public:
-    /// The func argument must be constructed from the C++11 __func__ macro.
-    /// Ref: https://en.cppreference.com/w/cpp/language/function.html#func
-    /// Non-static string literals are not supported.
-    SourceLocation(const char* func,
-                   std::source_location loc = std::source_location::current())
-        : m_func{func}, m_loc{loc} {}
-
-    std::string_view file_name() const { return m_loc.file_name(); }
-    std::uint_least32_t line() const { return m_loc.line(); }
-    std::string_view function_name_short() const { return m_func; }
-
-private:
-    std::string_view m_func;
-    std::source_location m_loc;
-};
-
 struct SourceLocationEqual {
     bool operator()(const SourceLocation& lhs, const SourceLocation& rhs) const noexcept
     {
@@ -81,51 +58,6 @@ struct LogCategory {
 };
 
 namespace BCLog {
-    using CategoryMask = uint64_t;
-    enum LogFlags : CategoryMask {
-        NONE        = CategoryMask{0},
-        NET         = (CategoryMask{1} <<  0),
-        TOR         = (CategoryMask{1} <<  1),
-        MEMPOOL     = (CategoryMask{1} <<  2),
-        HTTP        = (CategoryMask{1} <<  3),
-        BENCH       = (CategoryMask{1} <<  4),
-        ZMQ         = (CategoryMask{1} <<  5),
-        WALLETDB    = (CategoryMask{1} <<  6),
-        RPC         = (CategoryMask{1} <<  7),
-        ESTIMATEFEE = (CategoryMask{1} <<  8),
-        ADDRMAN     = (CategoryMask{1} <<  9),
-        SELECTCOINS = (CategoryMask{1} << 10),
-        REINDEX     = (CategoryMask{1} << 11),
-        CMPCTBLOCK  = (CategoryMask{1} << 12),
-        RAND        = (CategoryMask{1} << 13),
-        PRUNE       = (CategoryMask{1} << 14),
-        PROXY       = (CategoryMask{1} << 15),
-        MEMPOOLREJ  = (CategoryMask{1} << 16),
-        LIBEVENT    = (CategoryMask{1} << 17),
-        COINDB      = (CategoryMask{1} << 18),
-        QT          = (CategoryMask{1} << 19),
-        LEVELDB     = (CategoryMask{1} << 20),
-        VALIDATION  = (CategoryMask{1} << 21),
-        I2P         = (CategoryMask{1} << 22),
-        IPC         = (CategoryMask{1} << 23),
-#ifdef DEBUG_LOCKCONTENTION
-        LOCK        = (CategoryMask{1} << 24),
-#endif
-        BLOCKSTORAGE = (CategoryMask{1} << 25),
-        TXRECONCILIATION = (CategoryMask{1} << 26),
-        SCAN        = (CategoryMask{1} << 27),
-        TXPACKAGES  = (CategoryMask{1} << 28),
-        KERNEL      = (CategoryMask{1} << 29),
-        PRIVBROADCAST = (CategoryMask{1} << 30),
-        ALL         = ~NONE,
-    };
-    enum class Level {
-        Trace = 0, // High-volume or detailed logging for development/debugging
-        Debug,     // Reasonably noisy logging, but still usable in production
-        Info,      // Default
-        Warning,
-        Error,
-    };
     constexpr auto DEFAULT_LOG_LEVEL{Level::Debug};
     constexpr size_t DEFAULT_MAX_LOG_BUFFER{1'000'000}; // buffer up to 1MB of log data prior to StartLogging
     constexpr uint64_t RATELIMIT_MAX_BYTES{1024 * 1024}; // maximum number of bytes per source location that can be logged within the RATELIMIT_WINDOW
@@ -367,49 +299,4 @@ static inline bool LogAcceptCategory(BCLog::LogFlags category, BCLog::Level leve
 /** Return true if str parses as a log category and set the flag */
 bool GetLogCategory(BCLog::LogFlags& flag, std::string_view str);
 
-template <typename... Args>
-inline void LogPrintFormatInternal(SourceLocation&& source_loc, BCLog::LogFlags flag, BCLog::Level level, bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
-{
-    if (LogInstance().Enabled()) {
-        std::string log_msg;
-        try {
-            log_msg = tfm::format(fmt, args...);
-        } catch (tinyformat::format_error& fmterr) {
-            log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
-        }
-        LogInstance().LogPrintStr(log_msg, std::move(source_loc), flag, level, should_ratelimit);
-    }
-}
-
-// Allow __func__ to be used in any context without warnings:
-// NOLINTNEXTLINE(bugprone-lambda-function-name)
-#define LogPrintLevel_(category, level, should_ratelimit, ...) LogPrintFormatInternal(SourceLocation{__func__}, category, level, should_ratelimit, __VA_ARGS__)
-
-// Log unconditionally. Uses basic rate limiting to mitigate disk filling attacks.
-// Be conservative when using functions that unconditionally log to debug.log!
-// It should not be the case that an inbound peer can fill up a user's storage
-// with debug.log entries.
-#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/true, __VA_ARGS__)
-#define LogWarning(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Warning, /*should_ratelimit=*/true, __VA_ARGS__)
-#define LogError(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Error, /*should_ratelimit=*/true, __VA_ARGS__)
-
-// Use a macro instead of a function for conditional logging to prevent
-// evaluating arguments when logging for the category is not enabled.
-
-// Log by prefixing the output with the passed category name and severity level. This logs conditionally if
-// the category is allowed. No rate limiting is applied, because users specifying -debug are assumed to be
-// developers or power users who are aware that -debug may cause excessive disk usage due to logging.
-#define detail_LogIfCategoryAndLevelEnabled(category, level, ...)     \
-    do {                                                              \
-        if (LogAcceptCategory((category), (level))) {                 \
-            bool rate_limit{level >= BCLog::Level::Info};             \
-            Assume(!rate_limit);/*Only called with the levels below*/ \
-            LogPrintLevel_(category, level, rate_limit, __VA_ARGS__); \
-        }                                                             \
-    } while (0)
-
-// Log conditionally, prefixing the output with the passed category name.
-#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, BCLog::Level::Debug, __VA_ARGS__)
-#define LogTrace(category, ...) detail_LogIfCategoryAndLevelEnabled(category, BCLog::Level::Trace, __VA_ARGS__)
-
 #endif // BITCOIN_LOGGING_H
diff --git a/src/logging/categories.h b/src/logging/categories.h
new file mode 100644
index 00000000000..dff00adaf1a
--- /dev/null
+++ b/src/logging/categories.h
@@ -0,0 +1,54 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_LOGGING_CATEGORIES_H
+#define BITCOIN_LOGGING_CATEGORIES_H
+
+#include <cstdint>
+
+namespace BCLog {
+
+using CategoryMask = uint64_t;
+
+enum LogFlags : CategoryMask {
+    NONE = CategoryMask{0},
+    NET = (CategoryMask{1} << 0),
+    TOR = (CategoryMask{1} << 1),
+    MEMPOOL = (CategoryMask{1} << 2),
+    HTTP = (CategoryMask{1} << 3),
+    BENCH = (CategoryMask{1} << 4),
+    ZMQ = (CategoryMask{1} << 5),
+    WALLETDB = (CategoryMask{1} << 6),
+    RPC = (CategoryMask{1} << 7),
+    ESTIMATEFEE = (CategoryMask{1} << 8),
+    ADDRMAN = (CategoryMask{1} << 9),
+    SELECTCOINS = (CategoryMask{1} << 10),
+    REINDEX = (CategoryMask{1} << 11),
+    CMPCTBLOCK = (CategoryMask{1} << 12),
+    RAND = (CategoryMask{1} << 13),
+    PRUNE = (CategoryMask{1} << 14),
+    PROXY = (CategoryMask{1} << 15),
+    MEMPOOLREJ = (CategoryMask{1} << 16),
+    LIBEVENT = (CategoryMask{1} << 17),
+    COINDB = (CategoryMask{1} << 18),
+    QT = (CategoryMask{1} << 19),
+    LEVELDB = (CategoryMask{1} << 20),
+    VALIDATION = (CategoryMask{1} << 21),
+    I2P = (CategoryMask{1} << 22),
+    IPC = (CategoryMask{1} << 23),
+#ifdef DEBUG_LOCKCONTENTION
+    LOCK = (CategoryMask{1} << 24),
+#endif
+    BLOCKSTORAGE = (CategoryMask{1} << 25),
+    TXRECONCILIATION = (CategoryMask{1} << 26),
+    SCAN = (CategoryMask{1} << 27),
+    TXPACKAGES = (CategoryMask{1} << 28),
+    KERNEL = (CategoryMask{1} << 29),
+    PRIVBROADCAST = (CategoryMask{1} << 30),
+    ALL = ~NONE,
+};
+
+} // namespace BCLog
+
+#endif // BITCOIN_LOGGING_CATEGORIES_H
diff --git a/src/logging/timer.h b/src/logging/timer.h
index 52a86e714ad..2b183822e96 100644
--- a/src/logging/timer.h
+++ b/src/logging/timer.h
@@ -6,7 +6,7 @@
 #ifndef BITCOIN_LOGGING_TIMER_H
 #define BITCOIN_LOGGING_TIMER_H
 
-#include <logging.h>
+#include <util/log.h>
 #include <util/macros.h>
 #include <util/time.h>
 #include <util/types.h>
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 37bf1799aa4..ddaaad19c76 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -16,7 +16,6 @@
 #include <kernel/messagestartchars.h>
 #include <kernel/notifications_interface.h>
 #include <kernel/types.h>
-#include <logging.h>
 #include <pow.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
@@ -31,6 +30,7 @@
 #include <util/check.h>
 #include <util/expected.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <util/obfuscation.h>
 #include <util/overflow.h>
 #include <util/result.h>
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index 930d843121a..b3e9753e5a7 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -9,7 +9,6 @@
 #include <coins.h>
 #include <consensus/params.h>
 #include <kernel/caches.h>
-#include <logging.h>
 #include <node/blockstorage.h>
 #include <sync.h>
 #include <threadsafety.h>
@@ -17,6 +16,7 @@
 #include <txdb.h>
 #include <uint256.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <util/signalinterrupt.h>
 #include <util/time.h>
 #include <util/translation.h>
diff --git a/src/node/utxo_snapshot.cpp b/src/node/utxo_snapshot.cpp
index f11e979a357..e5997b7b65b 100644
--- a/src/node/utxo_snapshot.cpp
+++ b/src/node/utxo_snapshot.cpp
@@ -4,12 +4,12 @@
 
 #include <node/utxo_snapshot.h>
 
-#include <logging.h>
 #include <streams.h>
 #include <sync.h>
 #include <tinyformat.h>
 #include <uint256.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <validation.h>
 
 #include <cassert>
diff --git a/src/policy/truc_policy.cpp b/src/policy/truc_policy.cpp
index 597d08f7063..2ecb763e6c3 100644
--- a/src/policy/truc_policy.cpp
+++ b/src/policy/truc_policy.cpp
@@ -6,7 +6,6 @@
 
 #include <coins.h>
 #include <consensus/amount.h>
-#include <logging.h>
 #include <tinyformat.h>
 #include <util/check.h>
 
diff --git a/src/random.cpp b/src/random.cpp
index aeaf6baa8e8..f1c4bb86ff2 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -12,12 +12,12 @@
 #include <crypto/chacha20.h>
 #include <crypto/sha256.h>
 #include <crypto/sha512.h>
-#include <logging.h>
 #include <randomenv.h>
 #include <span.h>
 #include <support/allocators/secure.h>
 #include <support/cleanse.h>
 #include <sync.h>
+#include <util/log.h>
 #include <util/time.h>
 
 #include <array>
diff --git a/src/script/sigcache.cpp b/src/script/sigcache.cpp
index 77ffbabdf09..90d1c845c36 100644
--- a/src/script/sigcache.cpp
+++ b/src/script/sigcache.cpp
@@ -6,12 +6,12 @@
 #include <script/sigcache.h>
 
 #include <crypto/sha256.h>
-#include <logging.h>
 #include <pubkey.h>
 #include <random.h>
 #include <script/interpreter.h>
 #include <span.h>
 #include <uint256.h>
+#include <util/log.h>
 
 #include <mutex>
 #include <shared_mutex>
diff --git a/src/signet.cpp b/src/signet.cpp
index d874ddc1a65..d0f8aa28515 100644
--- a/src/signet.cpp
+++ b/src/signet.cpp
@@ -7,7 +7,6 @@
 #include <consensus/merkle.h>
 #include <consensus/params.h>
 #include <consensus/validation.h>
-#include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
@@ -15,6 +14,7 @@
 #include <streams.h>
 #include <uint256.h>
 #include <util/check.h>
+#include <util/log.h>
 
 #include <algorithm>
 #include <cstddef>
diff --git a/src/streams.h b/src/streams.h
index be6b7452a86..f70adcf74a7 100644
--- a/src/streams.h
+++ b/src/streams.h
@@ -6,11 +6,11 @@
 #ifndef BITCOIN_STREAMS_H
 #define BITCOIN_STREAMS_H
 
-#include <logging.h>
 #include <serialize.h>
 #include <span.h>
 #include <support/allocators/zeroafterfree.h>
 #include <util/check.h>
+#include <util/log.h>
 #include <util/obfuscation.h>
 #include <util/overflow.h>
 #include <util/syserror.h>
diff --git a/src/sync.cpp b/src/sync.cpp
index b661aad94b6..e59f86b94fc 100644
--- a/src/sync.cpp
+++ b/src/sync.cpp
@@ -4,8 +4,8 @@
 
 #include <sync.h>
 
-#include <logging.h>
 #include <tinyformat.h>
+#include <util/log.h>
 #include <util/strencodings.h>
 #include <util/threadnames.h>
 
diff --git a/src/sync.h b/src/sync.h
index 01e92e6e42c..548b51d9d16 100644
--- a/src/sync.h
+++ b/src/sync.h
@@ -7,7 +7,6 @@
 #define BITCOIN_SYNC_H
 
 #ifdef DEBUG_LOCKCONTENTION
-#include <logging.h>
 #include <logging/timer.h>
 #endif
 
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 141c31c5d51..21f6eb93867 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -7,11 +7,11 @@
 
 #include <coins.h>
 #include <dbwrapper.h>
-#include <logging.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <serialize.h>
 #include <uint256.h>
+#include <util/log.h>
 #include <util/vector.h>
 
 #include <cassert>
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 2486270bc0d..55c332769d4 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -11,13 +11,13 @@
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
-#include <logging.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <random.h>
 #include <tinyformat.h>
 #include <util/check.h>
 #include <util/feefrac.h>
+#include <util/log.h>
 #include <util/moneystr.h>
 #include <util/overflow.h>
 #include <util/result.h>
diff --git a/src/util/asmap.cpp b/src/util/asmap.cpp
index 4d4ed4fe869..f8b5a527a93 100644
--- a/src/util/asmap.cpp
+++ b/src/util/asmap.cpp
@@ -6,11 +6,11 @@
 
 #include <clientversion.h>
 #include <hash.h>
-#include <logging.h>
 #include <serialize.h>
 #include <streams.h>
 #include <uint256.h>
 #include <util/fs.h>
+#include <util/log.h>
 
 #include <algorithm>
 #include <bit>
diff --git a/src/util/batchpriority.cpp b/src/util/batchpriority.cpp
index 86abc011513..e6bb43b4aca 100644
--- a/src/util/batchpriority.cpp
+++ b/src/util/batchpriority.cpp
@@ -4,7 +4,7 @@
 
 #include <util/batchpriority.h>
 
-#include <logging.h>
+#include <util/log.h>
 #include <util/syserror.h>
 
 #include <string>
diff --git a/src/util/exception.cpp b/src/util/exception.cpp
index a4421226551..cd2bd231879 100644
--- a/src/util/exception.cpp
+++ b/src/util/exception.cpp
@@ -5,8 +5,8 @@
 
 #include <util/exception.h>
 
-#include <logging.h>
 #include <tinyformat.h>
+#include <util/log.h>
 
 #include <exception>
 #include <iostream>
diff --git a/src/util/fs_helpers.cpp b/src/util/fs_helpers.cpp
index 98646c021ea..e7780d743c1 100644
--- a/src/util/fs_helpers.cpp
+++ b/src/util/fs_helpers.cpp
@@ -3,13 +3,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <util/fs_helpers.h>
-
 #include <bitcoin-build-config.h> // IWYU pragma: keep
 
-#include <logging.h>
+#include <util/fs_helpers.h>
+
 #include <sync.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <util/syserror.h>
 
 #include <cerrno>
diff --git a/src/util/log.h b/src/util/log.h
new file mode 100644
index 00000000000..aae23f0df1e
--- /dev/null
+++ b/src/util/log.h
@@ -0,0 +1,118 @@
+// Copyright (c) The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_UTIL_LOG_H
+#define BITCOIN_UTIL_LOG_H
+
+#include <logging/categories.h> // IWYU pragma: export
+#include <tinyformat.h>
+#include <util/check.h>
+
+#include <cstdint>
+#include <source_location>
+#include <string>
+#include <string_view>
+
+/// Like std::source_location, but allowing to override the function name.
+class SourceLocation
+{
+public:
+    /// The func argument must be constructed from the C++11 __func__ macro.
+    /// Ref: https://en.cppreference.com/w/cpp/language/function.html#func
+    /// Non-static string literals are not supported.
+    SourceLocation(const char* func,
+                   std::source_location loc = std::source_location::current())
+        : m_func{func}, m_loc{loc} {}
+
+    std::string_view file_name() const { return m_loc.file_name(); }
+    std::uint_least32_t line() const { return m_loc.line(); }
+    std::string_view function_name_short() const { return m_func; }
+
+private:
+    std::string_view m_func;
+    std::source_location m_loc;
+};
+
+namespace util::log {
+/** Opaque to util::log; interpreted by consumers (e.g., BCLog::LogFlags). */
+using Category = uint64_t;
+
+enum class Level {
+    Trace = 0, // High-volume or detailed logging for development/debugging
+    Debug,     // Reasonably noisy logging, but still usable in production
+    Info,      // Default
+    Warning,
+    Error,
+};
+
+struct Entry {
+    Category category;
+    Level level;
+    bool should_ratelimit{false}; //!< Hint for consumers if this entry should be ratelimited
+    SourceLocation source_loc;
+    std::string message;
+};
+
+/** Return whether messages with specified category and level should be logged. Applications using
+ * the logging library need to provide this. */
+bool ShouldLog(Category category, Level level);
+
+/** Send message to be logged. Applications using the logging library need to provide this. */
+void Log(Entry entry);
+} // namespace util::log
+
+namespace BCLog {
+//! Alias for compatibility. Prefer util::log::Level over BCLog::Level in new code.
+using Level = util::log::Level;
+} // namespace BCLog
+
+template <typename... Args>
+inline void LogPrintFormatInternal(SourceLocation&& source_loc, BCLog::LogFlags flag, BCLog::Level level, bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
+{
+    std::string log_msg;
+    try {
+        log_msg = tfm::format(fmt, args...);
+    } catch (tinyformat::format_error& fmterr) {
+        log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
+    }
+    util::log::Log(util::log::Entry{
+        .category = flag,
+        .level = level,
+        .should_ratelimit = should_ratelimit,
+        .source_loc = std::move(source_loc),
+        .message = std::move(log_msg)});
+}
+
+// Allow __func__ to be used in any context without warnings:
+// NOLINTNEXTLINE(bugprone-lambda-function-name)
+#define LogPrintLevel_(category, level, should_ratelimit, ...) LogPrintFormatInternal(SourceLocation{__func__}, category, level, should_ratelimit, __VA_ARGS__)
+
+// Log unconditionally. Uses basic rate limiting to mitigate disk filling attacks.
+// Be conservative when using functions that unconditionally log to debug.log!
+// It should not be the case that an inbound peer can fill up a user's storage
+// with debug.log entries.
+#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/true, __VA_ARGS__)
+#define LogWarning(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Warning, /*should_ratelimit=*/true, __VA_ARGS__)
+#define LogError(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Error, /*should_ratelimit=*/true, __VA_ARGS__)
+
+// Use a macro instead of a function for conditional logging to prevent
+// evaluating arguments when logging for the category is not enabled.
+
+// Log by prefixing the output with the passed category name and severity level. This logs conditionally if
+// the category is allowed. No rate limiting is applied, because users specifying -debug are assumed to be
+// developers or power users who are aware that -debug may cause excessive disk usage due to logging.
+#define detail_LogIfCategoryAndLevelEnabled(category, level, ...)      \
+    do {                                                               \
+        if (util::log::ShouldLog((category), (level))) {               \
+            bool rate_limit{level >= BCLog::Level::Info};              \
+            Assume(!rate_limit); /*Only called with the levels below*/ \
+            LogPrintLevel_(category, level, rate_limit, __VA_ARGS__);  \
+        }                                                              \
+    } while (0)
+
+// Log conditionally, prefixing the output with the passed category name.
+#define LogDebug(category, ...) detail_LogIfCategoryAndLevelEnabled(category, BCLog::Level::Debug, __VA_ARGS__)
+#define LogTrace(category, ...) detail_LogIfCategoryAndLevelEnabled(category, BCLog::Level::Trace, __VA_ARGS__)
+
+#endif // BITCOIN_UTIL_LOG_H
diff --git a/src/util/sock.cpp b/src/util/sock.cpp
index ba822a0eaf7..f13406ebe5e 100644
--- a/src/util/sock.cpp
+++ b/src/util/sock.cpp
@@ -2,11 +2,13 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <util/sock.h>
+
 #include <common/system.h>
 #include <compat/compat.h>
-#include <logging.h>
+#include <span.h>
 #include <tinyformat.h>
-#include <util/sock.h>
+#include <util/log.h>
 #include <util/syserror.h>
 #include <util/threadinterrupt.h>
 #include <util/time.h>
diff --git a/src/util/sock.h b/src/util/sock.h
index 69ec1b8e01d..8c51b8ea6ea 100644
--- a/src/util/sock.h
+++ b/src/util/sock.h
@@ -11,6 +11,7 @@
 
 #include <chrono>
 #include <memory>
+#include <span>
 #include <string>
 #include <unordered_map>
 
diff --git a/src/util/thread.cpp b/src/util/thread.cpp
index 7f8fa20a237..0fde73c4e29 100644
--- a/src/util/thread.cpp
+++ b/src/util/thread.cpp
@@ -4,8 +4,8 @@
 
 #include <util/thread.h>
 
-#include <logging.h>
 #include <util/exception.h>
+#include <util/log.h>
 #include <util/threadnames.h>
 
 #include <exception>
diff --git a/src/validation.cpp b/src/validation.cpp
index f2819695da2..c200c3d6cd8 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -28,7 +28,6 @@
 #include <kernel/notifications_interface.h>
 #include <kernel/types.h>
 #include <kernel/warning.h>
-#include <logging.h>
 #include <logging/timer.h>
 #include <node/blockstorage.h>
 #include <node/utxo_snapshot.h>
@@ -53,6 +52,7 @@
 #include <util/fs.h>
 #include <util/fs_helpers.h>
 #include <util/hasher.h>
+#include <util/log.h>
 #include <util/moneystr.h>
 #include <util/rbf.h>
 #include <util/result.h>
@@ -2870,7 +2870,7 @@ static void UpdateTipLog(
     AssertLockHeld(::cs_main);
 
     // Disable rate limiting in LogPrintLevel_ so this source location may log during IBD.
-    LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/false, "%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s\n",
+    LogPrintLevel_(BCLog::LogFlags::ALL, util::log::Level::Info, /*should_ratelimit=*/false, "%s%s: new best=%s height=%d version=0x%08x log2_work=%f tx=%lu date='%s' progress=%f cache=%.1fMiB(%utxo)%s\n",
                    prefix, func_name,
                    tip->GetBlockHash().ToString(), tip->nHeight, tip->nVersion,
                    log(tip->nChainWork.getdouble()) / log(2.0), tip->m_chain_tx_count,
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
index 586d29f4806..c7be6abc3a1 100644
--- a/src/validationinterface.cpp
+++ b/src/validationinterface.cpp
@@ -10,10 +10,10 @@
 #include <kernel/mempool_entry.h>
 #include <kernel/mempool_removal_reason.h>
 #include <kernel/types.h>
-#include <logging.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <util/check.h>
+#include <util/log.h>
 #include <util/task_runner.h>
 
 #include <future>