diff --git a/src/Makefile.am b/src/Makefile.am
index e6684ec9c2ae..5a2dcc63396b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -330,7 +330,7 @@ BITCOIN_CORE_H = \
   llmq/net_quorum.h \
   llmq/net_signing.h \
   llmq/observer.h \
-  llmq/options.h \
+  llmq/options_args.h \
   llmq/params.h \
   llmq/quorumproofdata.h \
   llmq/quorumproofs.h \
@@ -630,7 +630,7 @@ libbitcoin_node_a_SOURCES = \
   llmq/net_quorum.cpp \
   llmq/net_signing.cpp \
   llmq/observer.cpp \
-  llmq/options.cpp \
+  llmq/options_args.cpp \
   llmq/quorumproofs.cpp \
   llmq/quorums.cpp \
   llmq/quorumsman.cpp \
@@ -1300,7 +1300,6 @@ libdashkernel_la_SOURCES = \
   common/bloom.cpp \
   common/config.cpp \
   common/settings.cpp \
-  common/system.cpp \
   compressor.cpp \
   consensus/merkle.cpp \
   consensus/tx_check.cpp \
@@ -1328,9 +1327,6 @@ libdashkernel_la_SOURCES = \
   gsl/assert.cpp \
   hash.cpp \
   index/addressindex_util.cpp \
-  index/base.cpp \
-  index/txindex.cpp \
-  init/common.cpp \
   instantsend/db.cpp \
   instantsend/instantsend.cpp \
   instantsend/lock.cpp \
@@ -1348,7 +1344,6 @@ libdashkernel_la_SOURCES = \
   llmq/commitment.cpp \
   llmq/context.cpp \
   llmq/dkgsessionmgr.cpp \
-  llmq/options.cpp \
   llmq/quorums.cpp \
   llmq/quorumsman.cpp \
   llmq/signhash.cpp \
@@ -1364,9 +1359,7 @@ libdashkernel_la_SOURCES = \
   netbase.cpp \
   node/blockstorage.cpp \
   node/chainstate.cpp \
-  node/database_args.cpp \
   node/interface_ui.cpp \
-  node/transaction.cpp \
   node/utxo_snapshot.cpp \
   policy/feerate.cpp \
   policy/fees.cpp \
diff --git a/src/active/dkgsession.cpp b/src/active/dkgsession.cpp
index d3a7753c984b..98e5422289d7 100644
--- a/src/active/dkgsession.cpp
+++ b/src/active/dkgsession.cpp
@@ -10,7 +10,6 @@
 #include <llmq/debug.h>
 #include <llmq/dkgsessionhandler.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <util/helpers.h>
diff --git a/src/active/dkgsessionhandler.cpp b/src/active/dkgsessionhandler.cpp
index c11fcd3d18cd..1d540275efda 100644
--- a/src/active/dkgsessionhandler.cpp
+++ b/src/active/dkgsessionhandler.cpp
@@ -9,6 +9,7 @@
 #include <llmq/debug.h>
 #include <llmq/dkgsession.h>
 #include <llmq/net_quorum.h>
+#include <llmq/utils.h>
 
 #include <chainparams.h>
 #include <deploymentstatus.h>
diff --git a/src/bench/bls.cpp b/src/bench/bls.cpp
index d673d62a25b1..4e4cf76bda47 100644
--- a/src/bench/bls.cpp
+++ b/src/bench/bls.cpp
@@ -5,7 +5,7 @@
 #include <bench/bench.h>
 
 #include <bls/bls_worker.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 
 #include <random.h>
 #include <util/time.h>
diff --git a/src/bench/bls_dkg.cpp b/src/bench/bls_dkg.cpp
index bdf9015be8b7..0e3719643e1e 100644
--- a/src/bench/bls_dkg.cpp
+++ b/src/bench/bls_dkg.cpp
@@ -5,7 +5,7 @@
 #include <bench/bench.h>
 
 #include <bls/bls_worker.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <util/helpers.h>
 
 #include <random.h>
diff --git a/src/bitcoin-chainstate.cpp b/src/bitcoin-chainstate.cpp
index e8dc69795298..4a5be0957adb 100644
--- a/src/bitcoin-chainstate.cpp
+++ b/src/bitcoin-chainstate.cpp
@@ -28,7 +28,7 @@
 #include <evo/specialtxman.h>
 #include <init/common.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <masternode/meta.h>
 #include <node/blockstorage.h>
 #include <node/caches.h>
@@ -128,10 +128,10 @@ int main(int argc, char* argv[])
     };
     ChainstateManager chainman{chainman_opts, blockman_opts};
 
-    CMasternodeMetaMan metaman;
+    CMasternodeMetaMan metaman{abs_datadir};
     CEvoDB evodb{util::DbWrapperParams{.path = abs_datadir, .memory = false, .wipe = false}};
     CDeterministicMNManager dmnman{evodb, metaman};
-    CSporkManager sporkman;
+    CSporkManager sporkman{abs_datadir};
     chainlock::Chainlocks chainlocks(sporkman);
 
     auto llmq_ctx = WITH_LOCK(::cs_main, return std::make_unique<LLMQContext>(dmnman, evodb, chainman,
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 7e383a644ba3..be8bef23226e 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -8,7 +8,7 @@
 #include <random.h>
 
 #include <logging.h>
-#include <common/system.h>
+#include <util/thread.h>
 
 #include <algorithm>
 #include <map>
diff --git a/src/common/system.cpp b/src/common/system.cpp
index d9249c264495..f718d27501d1 100644
--- a/src/common/system.cpp
+++ b/src/common/system.cpp
@@ -6,11 +6,8 @@
 
 #include <common/system.h>
 
-#include <ctpl_stl.h>
 #include <logging.h>
-#include <tinyformat.h>
 #include <util/string.h>
-#include <util/threadnames.h>
 #include <util/time.h>
 
 #ifndef WIN32
@@ -24,9 +21,7 @@
 #endif
 
 #include <cstdlib>
-#include <future>
 #include <locale>
-#include <map>
 #include <stdexcept>
 #include <string>
 #include <thread>
@@ -69,44 +64,6 @@ void runCommand(const std::string& strCommand)
 }
 #endif
 
-void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName)
-{
-    auto cond = std::make_shared<std::condition_variable>();
-    auto mutex = std::make_shared<std::mutex>();
-    std::atomic<int> doneCnt(0);
-    std::map<int, std::future<void> > futures;
-
-    for (int i = 0; i < tp.size(); i++) {
-        futures[i] = tp.push([baseName, i, cond, mutex, &doneCnt](int threadId) {
-            util::ThreadRename(strprintf("%s-%d", baseName, i));
-            std::unique_lock<std::mutex> l(*mutex);
-            doneCnt++;
-            cond->wait(l);
-        });
-    }
-
-    do {
-        // Always sleep to let all threads acquire locks
-        UninterruptibleSleep(std::chrono::milliseconds{10});
-        // `doneCnt` should be at least `futures.size()` if tp size was increased (for whatever reason),
-        // or at least `tp.size()` if tp size was decreased and queue was cleared
-        // (which can happen on `stop()` if we were not fast enough to get all jobs to their threads).
-    } while (uint64_t(doneCnt) < futures.size() && doneCnt < tp.size());
-
-    cond->notify_all();
-
-    // Make sure no one is left behind, just in case
-    for (auto& pair : futures) {
-        auto& f = pair.second;
-        if (f.valid() && f.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout) {
-            LogPrintf("%s: %s-%d timed out\n", __func__, baseName, pair.first);
-            // Notify everyone again
-            cond->notify_all();
-            break;
-        }
-    }
-}
-
 void SetupEnvironment()
 {
 #ifdef HAVE_MALLOPT_ARENA_MAX
diff --git a/src/common/system.h b/src/common/system.h
index 8e54b9e526d1..681e9be299d1 100644
--- a/src/common/system.h
+++ b/src/common/system.h
@@ -36,11 +36,6 @@ std::string ShellEscape(const std::string& arg);
 void runCommand(const std::string& strCommand);
 #endif
 
-namespace ctpl {
-    class thread_pool;
-}
-void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName);
-
 /**
  * Return the number of cores available on the current system.
  * @note This does count virtual cores, such as those provided by HyperThreading.
diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp
index be084d47cdd6..a81a61a1648c 100644
--- a/src/evo/cbtx.cpp
+++ b/src/evo/cbtx.cpp
@@ -7,7 +7,6 @@
 #include <evo/specialtx.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <util/std23.h>
diff --git a/src/evo/core_write.cpp b/src/evo/core_write.cpp
index a5cbe174aee8..9cf595033941 100644
--- a/src/evo/core_write.cpp
+++ b/src/evo/core_write.cpp
@@ -14,6 +14,7 @@
 #include <llmq/commitment.h>
 #include <util/std23.h>
 
+#include <common/args.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <netaddress.h>
@@ -22,11 +23,19 @@
 
 #include <univalue.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <string>
 #include <type_traits>
 
 namespace {
+/** Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code */
+bool IsServiceDeprecatedRPCEnabled()
+{
+    const auto args = gArgs.GetArgs("-deprecatedrpc");
+    return std::find(args.begin(), args.end(), "service") != args.end();
+}
+
 template <typename Obj>
 std::string GetDeprecatedServiceField(const Obj& obj)
 {
@@ -191,6 +200,128 @@ UniValue CDeterministicMNState::ToJson(MnType nType) const
     return obj;
 }
 
+UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
+{
+    UniValue obj(UniValue::VOBJ);
+    if (fields & Field_nVersion) {
+        obj.pushKV("version", state.nVersion);
+    }
+    if (fields & Field_netInfo) {
+        if (IsServiceDeprecatedRPCEnabled()) {
+            obj.pushKV("service", state.netInfo->GetPrimary().ToStringAddrPort());
+        }
+    }
+    if (fields & Field_nRegisteredHeight) {
+        obj.pushKV("registeredHeight", state.nRegisteredHeight);
+    }
+    if (fields & Field_nLastPaidHeight) {
+        obj.pushKV("lastPaidHeight", state.nLastPaidHeight);
+    }
+    if (fields & Field_nConsecutivePayments) {
+        obj.pushKV("consecutivePayments", state.nConsecutivePayments);
+    }
+    if (fields & Field_nPoSePenalty) {
+        obj.pushKV("PoSePenalty", state.nPoSePenalty);
+    }
+    if (fields & Field_nPoSeRevivedHeight) {
+        obj.pushKV("PoSeRevivedHeight", state.nPoSeRevivedHeight);
+    }
+    if (fields & Field_nPoSeBanHeight) {
+        obj.pushKV("PoSeBanHeight", state.nPoSeBanHeight);
+    }
+    if (fields & Field_nRevocationReason) {
+        obj.pushKV("revocationReason", state.nRevocationReason);
+    }
+    if (fields & Field_keyIDOwner) {
+        obj.pushKV("ownerAddress", EncodeDestination(PKHash(state.keyIDOwner)));
+    }
+    if (fields & Field_keyIDVoting) {
+        obj.pushKV("votingAddress", EncodeDestination(PKHash(state.keyIDVoting)));
+    }
+    if (fields & Field_scriptPayout) {
+        CTxDestination dest;
+        if (ExtractDestination(state.scriptPayout, dest)) {
+            obj.pushKV("payoutAddress", EncodeDestination(dest));
+        }
+    }
+    if (fields & Field_payouts) {
+        obj.pushKV("payouts", PayoutListToJson(state.payouts));
+    }
+    if (fields & Field_shares) {
+        obj.pushKV("shares", ShareListToJson(state.shares));
+    }
+    if (fields & Field_nEarlyPeriodBlocks) {
+        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(state.nEarlyPeriodBlocks));
+    }
+    if (fields & Field_nEarlyPenalty) {
+        obj.pushKV("earlyPenalty", state.nEarlyPenalty);
+    }
+    if (fields & Field_scriptOperatorPayout) {
+        CTxDestination dest;
+        if (ExtractDestination(state.scriptOperatorPayout, dest)) {
+            obj.pushKV("operatorPayoutAddress", EncodeDestination(dest));
+        }
+    }
+    if (fields & Field_pubKeyOperator) {
+        obj.pushKV("pubKeyOperator", state.pubKeyOperator.ToString());
+    }
+    if (nType == MnType::Evo) {
+        if (fields & Field_platformNodeID) {
+            obj.pushKV("platformNodeID", state.platformNodeID.ToString());
+        }
+        if (IsServiceDeprecatedRPCEnabled()) {
+            // platformP2PPort/platformHTTPPort are deprecated scalar duplicates of netInfo's
+            // Platform entries. From ExtAddr onwards the scalar fields are unused (always 0), so
+            // when the diff carries an ExtAddr netInfo report the live port from it to stay
+            // consistent with the "addresses" output below.
+            const bool has_ext_netinfo = (fields & Field_netInfo) && state.netInfo->CanStorePlatform();
+            if (fields & Field_platformP2PPort) {
+                obj.pushKV("platformP2PPort", has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)
+                                                  ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort()
+                                                  : state.platformP2PPort);
+            }
+            if (fields & Field_platformHTTPPort) {
+                obj.pushKV("platformHTTPPort", has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS)
+                                                   ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort()
+                                                   : state.platformHTTPPort);
+            }
+        }
+    }
+    {
+        const bool has_netinfo = (fields & Field_netInfo);
+
+        UniValue netInfoObj(UniValue::VOBJ);
+        if (has_netinfo) {
+            netInfoObj = state.netInfo->ToJson();
+        }
+        if (nType == MnType::Evo && (!has_netinfo || !state.netInfo->CanStorePlatform())) {
+            auto unknownAddr = [](uint16_t port) -> UniValue {
+                UniValue obj(UniValue::VARR);
+                // We don't know what the address is because it wasn't changed in the
+                // diff but we still need to report the port number in addr:port format
+                obj.push_back(strprintf("255.255.255.255:%d", port));
+                return obj;
+            };
+            if (fields & Field_platformP2PPort) {
+                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
+                                  (has_netinfo)
+                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformP2PPort))
+                                      : unknownAddr(state.platformP2PPort));
+            }
+            if (fields & Field_platformHTTPPort) {
+                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
+                                  (has_netinfo)
+                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformHTTPPort))
+                                      : unknownAddr(state.platformHTTPPort));
+            }
+        }
+        if (!netInfoObj.empty()) {
+            obj.pushKV("addresses", netInfoObj);
+        }
+    }
+    return obj;
+}
+
 UniValue CProRegTx::ToJson() const
 {
     UniValue ret(UniValue::VOBJ);
diff --git a/src/evo/dmnstate.cpp b/src/evo/dmnstate.cpp
index 7a8e9da55434..e580456949f0 100644
--- a/src/evo/dmnstate.cpp
+++ b/src/evo/dmnstate.cpp
@@ -4,9 +4,7 @@
 
 #include <evo/dmnstate.h>
 
-#include <evo/netinfo.h>
 #include <script/standard.h>
-#include <univalue.h>
 
 std::string CDeterministicMNState::ToString() const
 {
@@ -46,127 +44,3 @@ std::vector<CScript> CDeterministicMNState::GetOwnerRewardScripts() const
     }
     return ret;
 }
-
-UniValue CDeterministicMNStateDiff::ToJson(MnType nType) const
-{
-    UniValue obj(UniValue::VOBJ);
-    if (fields & Field_nVersion) {
-        obj.pushKV("version", state.nVersion);
-    }
-    if (fields & Field_netInfo) {
-        if (IsServiceDeprecatedRPCEnabled()) {
-            obj.pushKV("service", state.netInfo->GetPrimary().ToStringAddrPort());
-        }
-    }
-    if (fields & Field_nRegisteredHeight) {
-        obj.pushKV("registeredHeight", state.nRegisteredHeight);
-    }
-    if (fields & Field_nLastPaidHeight) {
-        obj.pushKV("lastPaidHeight", state.nLastPaidHeight);
-    }
-    if (fields & Field_nConsecutivePayments) {
-        obj.pushKV("consecutivePayments", state.nConsecutivePayments);
-    }
-    if (fields & Field_nPoSePenalty) {
-        obj.pushKV("PoSePenalty", state.nPoSePenalty);
-    }
-    if (fields & Field_nPoSeRevivedHeight) {
-        obj.pushKV("PoSeRevivedHeight", state.nPoSeRevivedHeight);
-    }
-    if (fields & Field_nPoSeBanHeight) {
-        obj.pushKV("PoSeBanHeight", state.nPoSeBanHeight);
-    }
-    if (fields & Field_nRevocationReason) {
-        obj.pushKV("revocationReason", state.nRevocationReason);
-    }
-    if (fields & Field_keyIDOwner) {
-        obj.pushKV("ownerAddress", EncodeDestination(PKHash(state.keyIDOwner)));
-    }
-    if (fields & Field_keyIDVoting) {
-        obj.pushKV("votingAddress", EncodeDestination(PKHash(state.keyIDVoting)));
-    }
-    if (fields & Field_scriptPayout) {
-        CTxDestination dest;
-        if (ExtractDestination(state.scriptPayout, dest)) {
-            obj.pushKV("payoutAddress", EncodeDestination(dest));
-        }
-    }
-    if (fields & Field_payouts) {
-        obj.pushKV("payouts", PayoutListToJson(state.payouts));
-    }
-    if (fields & Field_shares) {
-        obj.pushKV("shares", ShareListToJson(state.shares));
-    }
-    if (fields & Field_nEarlyPeriodBlocks) {
-        obj.pushKV("earlyPeriodBlocks", static_cast<int64_t>(state.nEarlyPeriodBlocks));
-    }
-    if (fields & Field_nEarlyPenalty) {
-        obj.pushKV("earlyPenalty", state.nEarlyPenalty);
-    }
-    if (fields & Field_scriptOperatorPayout) {
-        CTxDestination dest;
-        if (ExtractDestination(state.scriptOperatorPayout, dest)) {
-            obj.pushKV("operatorPayoutAddress", EncodeDestination(dest));
-        }
-    }
-    if (fields & Field_pubKeyOperator) {
-        obj.pushKV("pubKeyOperator", state.pubKeyOperator.ToString());
-    }
-    if (nType == MnType::Evo) {
-        if (fields & Field_platformNodeID) {
-            obj.pushKV("platformNodeID", state.platformNodeID.ToString());
-        }
-        if (IsServiceDeprecatedRPCEnabled()) {
-            // platformP2PPort/platformHTTPPort are deprecated scalar duplicates of netInfo's
-            // Platform entries. From ExtAddr onwards the scalar fields are unused (always 0), so
-            // when the diff carries an ExtAddr netInfo report the live port from it to stay
-            // consistent with the "addresses" output below.
-            const bool has_ext_netinfo = (fields & Field_netInfo) && state.netInfo->CanStorePlatform();
-            if (fields & Field_platformP2PPort) {
-                obj.pushKV("platformP2PPort",
-                           has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_P2P)
-                               ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_P2P)[0].GetPort()
-                               : state.platformP2PPort);
-            }
-            if (fields & Field_platformHTTPPort) {
-                obj.pushKV("platformHTTPPort",
-                           has_ext_netinfo && state.netInfo->HasEntries(NetInfoPurpose::PLATFORM_HTTPS)
-                               ? state.netInfo->GetEntries(NetInfoPurpose::PLATFORM_HTTPS)[0].GetPort()
-                               : state.platformHTTPPort);
-            }
-        }
-    }
-    {
-        const bool has_netinfo = (fields & Field_netInfo);
-
-        UniValue netInfoObj(UniValue::VOBJ);
-        if (has_netinfo) {
-            netInfoObj = state.netInfo->ToJson();
-        }
-        if (nType == MnType::Evo && (!has_netinfo || !state.netInfo->CanStorePlatform())) {
-            auto unknownAddr = [](uint16_t port) -> UniValue {
-                UniValue obj(UniValue::VARR);
-                // We don't know what the address is because it wasn't changed in the
-                // diff but we still need to report the port number in addr:port format
-                obj.push_back(strprintf("255.255.255.255:%d", port));
-                return obj;
-            };
-            if (fields & Field_platformP2PPort) {
-                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_P2P).data(),
-                                  (has_netinfo)
-                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformP2PPort))
-                                      : unknownAddr(state.platformP2PPort));
-            }
-            if (fields & Field_platformHTTPPort) {
-                netInfoObj.pushKV(PurposeToString(NetInfoPurpose::PLATFORM_HTTPS).data(),
-                                  (has_netinfo)
-                                      ? ArrFromService(CService(state.netInfo->GetPrimary(), state.platformHTTPPort))
-                                      : unknownAddr(state.platformHTTPPort));
-            }
-        }
-        if (!netInfoObj.empty()) {
-            obj.pushKV("addresses", netInfoObj);
-        }
-    }
-    return obj;
-}
diff --git a/src/evo/mnhftx.cpp b/src/evo/mnhftx.cpp
index 1a2555cd3628..f17b520c1189 100644
--- a/src/evo/mnhftx.cpp
+++ b/src/evo/mnhftx.cpp
@@ -75,7 +75,7 @@ CMNHFManager::Signals CMNHFManager::GetSignalsStage(const CBlockIndex* const pin
         assert(signal_pindex != nullptr);
         const int64_t signal_time = signal_pindex->GetMedianTimePast();
         for (int index = 0; index < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; ++index) {
-            const auto& deployment = Params().GetConsensus().vDeployments[index];
+            const auto& deployment = m_consensus_params.vDeployments[index];
             if (deployment.bit != signal.first) continue;
             if (signal_time < deployment.nStartTime) {
                 // new deployment is using the same bit as the old one
diff --git a/src/evo/netinfo.cpp b/src/evo/netinfo.cpp
index aa27f5863ff7..fea370c5403b 100644
--- a/src/evo/netinfo.cpp
+++ b/src/evo/netinfo.cpp
@@ -2,11 +2,9 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <common/args.h>
 #include <evo/netinfo.h>
 
 #include <chainparams.h>
-#include <common/system.h>
 #include <evo/types.h>
 #include <netbase.h>
 #include <span.h>
@@ -90,15 +88,9 @@ NetInfoStatus ValidateMainnetPrimaryPort(NetInfoPurpose purpose, const NetInfoEn
 
 bool IsNodeOnMainnet() { return Params().GetChainType() == ChainType::MAIN; }
 
-bool IsServiceDeprecatedRPCEnabled()
-{
-    const auto args = gArgs.GetArgs("-deprecatedrpc");
-    return std::find(args.begin(), args.end(), "service") != args.end();
-}
-
 const CChainParams& MainParams()
 {
-    std::call_once(g_main_params_flag, [&]() { g_main_params = CreateChainParams(::gArgs, ChainType::MAIN); });
+    std::call_once(g_main_params_flag, [&]() { g_main_params = CChainParams::Main(); });
     return *Assert(g_main_params);
 }
 
diff --git a/src/evo/netinfo.h b/src/evo/netinfo.h
index adedf33cf9b8..b7e6d594a544 100644
--- a/src/evo/netinfo.h
+++ b/src/evo/netinfo.h
@@ -105,9 +105,6 @@ constexpr std::string_view PurposeToString(const NetInfoPurpose purpose)
 /** Will return true if node is running on mainnet */
 bool IsNodeOnMainnet();
 
-/** Identical to IsDeprecatedRPCEnabled("service"). For use outside of RPC code */
-bool IsServiceDeprecatedRPCEnabled();
-
 /** Creates a one-element array using CService::ToStringPortAddr() output */
 UniValue ArrFromService(const CService& addr);
 
diff --git a/src/evo/snapshot.cpp b/src/evo/snapshot.cpp
index 04cffdba85e8..89c1f06cd529 100644
--- a/src/evo/snapshot.cpp
+++ b/src/evo/snapshot.cpp
@@ -13,7 +13,6 @@
 #include <evo/mnhftx.h>
 #include <evo/simplifiedmns.h>
 #include <hash.h>
-#include <llmq/options.h>
 #include <streams.h>
 #include <tinyformat.h>
 #include <util/check.h>
diff --git a/src/flat-database.h b/src/flat-database.h
index d4b32ba300b3..f0fb0209ab72 100644
--- a/src/flat-database.h
+++ b/src/flat-database.h
@@ -7,7 +7,6 @@
 
 #include <clientversion.h>
 #include <chainparams.h>
-#include <common/args.h>
 #include <common/system.h>
 #include <hash.h>
 #include <logging.h>
@@ -178,8 +177,8 @@ class CFlatDB
     }
 
 public:
-    CFlatDB(std::string&& strFilenameIn, std::string&& strMagicMessageIn) :
-        pathDB{gArgs.GetDataDirNet() / fs::u8path(strFilenameIn)},
+    CFlatDB(const fs::path& data_dir, std::string&& strFilenameIn, std::string&& strMagicMessageIn) :
+        pathDB{data_dir / fs::u8path(strFilenameIn)},
         strFilename{strFilenameIn},
         strMagicMessage{strMagicMessageIn}
     {
diff --git a/src/governance/governance.cpp b/src/governance/governance.cpp
index cb75a854a86b..c9559ec039c3 100644
--- a/src/governance/governance.cpp
+++ b/src/governance/governance.cpp
@@ -73,10 +73,11 @@ GovernanceStore::GovernanceStore() :
 {
 }
 
-CGovernanceManager::CGovernanceManager(CMasternodeMetaMan& mn_metaman, const ChainstateManager& chainman,
-                                       governance::SuperblockManager& superblocks, CDeterministicMNManager& dmnman,
-                                       CMasternodeSync& mn_sync, const governance::CollateralSource* collateral) :
-    m_db{std::make_unique<db_type>("governance.dat", "magicGovernanceCache")},
+CGovernanceManager::CGovernanceManager(const fs::path& data_dir, CMasternodeMetaMan& mn_metaman,
+                                       const ChainstateManager& chainman, governance::SuperblockManager& superblocks,
+                                       CDeterministicMNManager& dmnman, CMasternodeSync& mn_sync,
+                                       const governance::CollateralSource* collateral) :
+    m_db{std::make_unique<db_type>(data_dir, "governance.dat", "magicGovernanceCache")},
     m_mn_metaman{mn_metaman},
     m_chainman{chainman},
     m_superblocks{superblocks},
diff --git a/src/governance/governance.h b/src/governance/governance.h
index 6ae48b209e73..10be5d101e2c 100644
--- a/src/governance/governance.h
+++ b/src/governance/governance.h
@@ -11,6 +11,7 @@
 #include <kernel/cs_main.h> // IWYU pragma: export
 #include <primitives/transaction.h>
 #include <sync.h>
+#include <util/fs.h>
 #include <util/time.h>
 
 #include <atomic>
@@ -274,7 +275,7 @@ class CGovernanceManager : public GovernanceStore
     CGovernanceManager() = delete;
     CGovernanceManager(const CGovernanceManager&) = delete;
     CGovernanceManager& operator=(const CGovernanceManager&) = delete;
-    explicit CGovernanceManager(CMasternodeMetaMan& mn_metaman, const ChainstateManager& chainman,
+    explicit CGovernanceManager(const fs::path& data_dir, CMasternodeMetaMan& mn_metaman, const ChainstateManager& chainman,
                                 governance::SuperblockManager& superblocks, CDeterministicMNManager& dmnman,
                                 CMasternodeSync& mn_sync, const governance::CollateralSource* collateral);
     ~CGovernanceManager();
diff --git a/src/init.cpp b/src/init.cpp
index 62d7cc259e6c..17d9f335f9dc 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -65,6 +65,7 @@
 #include <node/mempool_persist_args.h>
 #include <node/miner.h>
 #include <node/peerman_args.h>
+#include <node/transaction.h>
 #include <node/sync_manager.h>
 #include <node/validation_cache_args.h>
 #include <policy/feerate.h>
@@ -127,7 +128,7 @@
 #include <llmq/net_quorum.h>
 #include <llmq/net_signing.h>
 #include <llmq/observer.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
 #include <masternode/utils.h>
@@ -1710,15 +1711,15 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 
     assert(!node.mn_metaman);
-    node.mn_metaman = std::make_unique<CMasternodeMetaMan>();
+    node.mn_metaman = std::make_unique<CMasternodeMetaMan>(args.GetDataDirNet());
 
     assert(!node.netfulfilledman);
-    node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
+    node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(args.GetDataDirNet());
 
     bool is_governance_enabled{!args.GetBoolArg("-disablegovernance", !DEFAULT_GOVERNANCE_ENABLE)};
 
     assert(!node.sporkman);
-    node.sporkman = std::make_unique<CSporkManager>();
+    node.sporkman = std::make_unique<CSporkManager>(args.GetDataDirNet());
     node.chainlocks = std::make_unique<chainlock::Chainlocks>(*node.sporkman);
     node.sbman = std::make_unique<governance::SuperblockManager>();
 
@@ -1951,6 +1952,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         [&chainman = node.chainman](CBlock& block, const CBlockIndex& index) {
             assert(chainman);
             return chainman->m_blockman.ReadBlockFromDisk(block, index);
+        },
+        [&chainman = node.chainman, &mempool = node.mempool](const uint256& txid) {
+            assert(chainman);
+            uint256 block_hash;
+            return node::GetTransaction(/*block_index=*/nullptr, mempool.get(), txid, block_hash, chainman->m_blockman);
         });
 
     if (g_zmq_notification_interface) {
@@ -2062,6 +2068,10 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         node::ChainstateLoadOptions options;
         options.chainlocks = Assert(node.chainlocks.get());
         options.data_dir = args.GetDataDirNet();
+        options.index_migration.address_index = args.GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
+        options.index_migration.spent_index = args.GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
+        options.index_migration.timestamp_index = args.GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
+        options.index_migration.batch_size = args.GetIntArg("-dbbatchsize", nDefaultDbBatchSize);
         options.reindex = node::fReindex;
         options.reindex_chainstate = fReindexChainState;
         options.prune = chainman.m_blockman.IsPruneMode();
@@ -2173,8 +2183,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     }
 
     assert(!node.govman);
-    node.govman = std::make_unique<CGovernanceManager>(*node.mn_metaman, *node.chainman, *node.sbman, *node.dmnman,
-                                                       *node.mn_sync, node.gov_collateral_index.get());
+    node.govman = std::make_unique<CGovernanceManager>(args.GetDataDirNet(), *node.mn_metaman, *node.chainman,
+                                                       *node.sbman, *node.dmnman, *node.mn_sync,
+                                                       node.gov_collateral_index.get());
 
     // ********************************************************* Step 7c: Setup masternode mode or watch-only mode
     assert(!node.active_ctx);
diff --git a/src/kernel/notifications_interface.h b/src/kernel/notifications_interface.h
index 48248e9aa0b6..af5867af9989 100644
--- a/src/kernel/notifications_interface.h
+++ b/src/kernel/notifications_interface.h
@@ -9,6 +9,7 @@
 #include <string>
 
 class CBlockIndex;
+class CDeterministicMNList;
 enum class SynchronizationState;
 struct bilingual_str;
 
@@ -27,6 +28,7 @@ class Notifications
     virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
     virtual void progress(const bilingual_str& title, int progress_percent, bool resume_possible) {}
     virtual void warning(const bilingual_str& warning) {}
+    virtual void masternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* index) {}
 };
 } // namespace kernel
 
diff --git a/src/llmq/blockprocessor.cpp b/src/llmq/blockprocessor.cpp
index f8442e093ab4..71038471930d 100644
--- a/src/llmq/blockprocessor.cpp
+++ b/src/llmq/blockprocessor.cpp
@@ -7,7 +7,6 @@
 #include <evo/evodb.h>
 #include <evo/specialtx.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <util/helpers.h>
 #include <util/std23.h>
@@ -127,7 +126,7 @@ MessageProcessingResult CQuorumBlockProcessor::ProcessMessage(const CNode& peer,
         return ret;
     }
 
-    const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "CQuorumBlockProcessor::%s -- invalid commitment type %d from peer=%d\n", __func__,
                  std23::to_underlying(qc.llmqType), peer.GetId());
@@ -328,7 +327,7 @@ bool CQuorumBlockProcessor::ProcessCommitment(Chainstate& chainstate, int nHeigh
 {
     AssertLockHeld(::cs_main);
 
-    const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.llmqType);
     if (!llmq_params_opt.has_value()) {
         LogPrint(BCLog::LLMQ, "%s -- invalid commitment type %d\n", __func__, std23::to_underlying(qc.llmqType));
         return false;
@@ -481,11 +480,11 @@ std::optional<std::pair<QcHashMap, QcIndexedHashMap>> CQuorumBlockProcessor::Get
     m_qc_hashes_cached.clear();
     m_qc_indexed_hashes_cached.clear();
     if (!m_qc_hashes_lru.IsInitialized()) {
-        m_qc_hashes_lru.Init(Params().GetConsensus());
+        m_qc_hashes_lru.Init(m_chainman.GetConsensus());
     }
 
     for (const auto& [llmqType, vecBlockIndexes] : quorums) {
-        const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+        const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
         assert(llmq_params_opt.has_value());
         bool rotation_enabled = IsQuorumRotationEnabled(llmq_params_opt.value(), pindexPrev);
         auto& vec_hashes = m_qc_hashes_cached[llmqType];
@@ -537,7 +536,7 @@ bool CQuorumBlockProcessor::UndoBlock(const Chainstate& chainstate, const CBlock
             LogPrint(BCLog::LLMQ, "%s -- retaining commitment for block %s used by another chainstate\n",
                      __func__, pindex->GetBlockHash().ToString());
         } else {
-            const auto& llmq_params_opt = Params().GetLLMQ(qc.llmqType);
+            const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.llmqType);
             assert(llmq_params_opt.has_value());
 
             if (IsQuorumRotationEnabled(llmq_params_opt.value(), pindex)) {
@@ -584,7 +583,7 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no
 {
     AssertLockHeld(::cs_main);
 
-    const auto& consensus = Params().GetConsensus();
+    const auto& consensus = m_chainman.GetConsensus();
 
     ret.clear();
 
@@ -598,7 +597,7 @@ bool CQuorumBlockProcessor::GetCommitmentsFromBlock(const CBlock& block, gsl::no
             }
             const auto& qc = *opt_qc;
 
-            const auto& llmq_params_opt = Params().GetLLMQ(qc.commitment.llmqType);
+            const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(qc.commitment.llmqType);
             if (!llmq_params_opt.has_value()) {
                 // should not happen as it was verified before processing the block
                 return state.Invalid(BlockValidationResult::BLOCK_CONSENSUS, "bad-qc-commitment-type");
@@ -798,7 +797,7 @@ std::optional<const CBlockIndex*> CQuorumBlockProcessor::GetLastMinedCommitments
 std::vector<const CBlockIndex*> CQuorumBlockProcessor::GetLastMinedCommitmentsPerQuorumIndexUntilBlock(
     Consensus::LLMQType llmqType, const CBlockIndex* pindex, size_t cycle) const
 {
-    const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
     std::vector<const CBlockIndex*> ret;
 
@@ -838,7 +837,7 @@ std::map<Consensus::LLMQType, std::vector<const CBlockIndex*>> CQuorumBlockProce
 {
     std::map<Consensus::LLMQType, std::vector<const CBlockIndex*>> ret;
 
-    for (const auto& params : Params().GetConsensus().llmqs) {
+    for (const auto& params : m_chainman.GetConsensus().llmqs) {
         auto& commitments = ret[params.type];
         if (IsQuorumRotationEnabled(params, pindex)) {
             commitments = GetLastMinedCommitmentsPerQuorumIndexUntilBlock(params.type, pindex, 0);
diff --git a/src/llmq/commitment.cpp b/src/llmq/commitment.cpp
index 3c4b91a6089e..038bb62c2c5d 100644
--- a/src/llmq/commitment.cpp
+++ b/src/llmq/commitment.cpp
@@ -5,7 +5,6 @@
 #include <llmq/commitment.h>
 
 #include <evo/deterministicmns.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <util/helpers.h>
 #include <util/std23.h>
diff --git a/src/llmq/context.h b/src/llmq/context.h
index 9033967bfc95..3176bc4e8c43 100644
--- a/src/llmq/context.h
+++ b/src/llmq/context.h
@@ -5,8 +5,7 @@
 #ifndef BITCOIN_LLMQ_CONTEXT_H
 #define BITCOIN_LLMQ_CONTEXT_H
 
-#include <llmq/options.h>
-
+#include <cstdint>
 #include <memory>
 
 class CBLSWorker;
diff --git a/src/llmq/dkgsession.cpp b/src/llmq/dkgsession.cpp
index 848afca9f1ee..0f511feb0d2b 100644
--- a/src/llmq/dkgsession.cpp
+++ b/src/llmq/dkgsession.cpp
@@ -10,7 +10,6 @@
 #include <llmq/commitment.h>
 #include <llmq/debug.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
 #include <util/helpers.h>
diff --git a/src/llmq/dkgsessionmgr.cpp b/src/llmq/dkgsessionmgr.cpp
index 9a8e5705a527..77f81eab13fa 100644
--- a/src/llmq/dkgsessionmgr.cpp
+++ b/src/llmq/dkgsessionmgr.cpp
@@ -7,7 +7,6 @@
 #include <bls/bls_ies.h>
 #include <evo/deterministicmns.h>
 #include <llmq/dkgsessionhandler.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <spork.h>
 #include <unordered_lru_cache.h>
@@ -44,8 +43,7 @@ void CDKGSessionManager::UpdatedBlockTip(const CBlockIndex* pindexNew, bool fIni
 
     if (fInitialDownload)
         return;
-    if (!DeploymentDIP0003Enforced(pindexNew->nHeight, Params().GetConsensus()))
-        return;
+    if (!DeploymentDIP0003Enforced(pindexNew->nHeight, m_chainman.GetConsensus())) return;
     if (!IsQuorumDKGEnabled(m_sporkman))
         return;
 
@@ -240,7 +238,7 @@ void CDKGSessionManager::CleanupOldContributions() const
 
     const auto prefixes = {DB_VVEC, DB_SKCONTRIB, DB_ENC_CONTRIB};
 
-    for (const auto& params : Params().GetConsensus().llmqs) {
+    for (const auto& params : m_chainman.GetConsensus().llmqs) {
         LogPrint(BCLog::LLMQ, "CDKGSessionManager::%s -- looking for old entries for llmq type %d\n", __func__, std23::to_underlying(params.type));
 
         CDBBatch batch(*db);
diff --git a/src/llmq/net_dkg.cpp b/src/llmq/net_dkg.cpp
index 279c7dbfd40c..d320c234af90 100644
--- a/src/llmq/net_dkg.cpp
+++ b/src/llmq/net_dkg.cpp
@@ -15,7 +15,6 @@
 #include <llmq/dkgsession.h>
 #include <llmq/dkgsessionmgr.h>
 #include <llmq/net_quorum.h>
-#include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <masternode/meta.h>
diff --git a/src/llmq/net_quorum.cpp b/src/llmq/net_quorum.cpp
index ef58ef006ea1..cde8776470b1 100644
--- a/src/llmq/net_quorum.cpp
+++ b/src/llmq/net_quorum.cpp
@@ -8,7 +8,7 @@
 #include <chainparams.h>
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/quorumsman.h>
 #include <llmq/utils.h>
 #include <logging.h>
diff --git a/src/llmq/net_quorum.h b/src/llmq/net_quorum.h
index 9f0558be106c..3a34be575ecd 100644
--- a/src/llmq/net_quorum.h
+++ b/src/llmq/net_quorum.h
@@ -6,7 +6,7 @@
 #define BITCOIN_LLMQ_NET_QUORUM_H
 
 #include <llmq/cache.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/quorums.h>
 #include <net_processing.h>
 #include <sync.h>
diff --git a/src/llmq/net_signing.cpp b/src/llmq/net_signing.cpp
index 2deef488632e..5ab60edb8d9c 100644
--- a/src/llmq/net_signing.cpp
+++ b/src/llmq/net_signing.cpp
@@ -7,8 +7,9 @@
 #include <bls/bls_batchverifier.h>
 #include <llmq/quorums.h>
 #include <llmq/signhash.h>
-#include <llmq/signing_shares.h>
 #include <llmq/signing.h>
+#include <llmq/signing_shares.h>
+#include <llmq/utils.h>
 #include <spork.h>
 
 #include <logging.h>
diff --git a/src/llmq/options.cpp b/src/llmq/options.cpp
deleted file mode 100644
index 3b93c6610336..000000000000
--- a/src/llmq/options.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright (c) 2018-2025 The Dash Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <common/args.h>
-#include <llmq/options.h>
-
-#include <spork.h>
-#include <util/helpers.h>
-#include <util/std23.h>
-
-#include <chainparams.h>
-#include <common/system.h>
-#include <consensus/params.h>
-#include <deploymentstatus.h>
-#include <validation.h>
-
-#include <algorithm>
-#include <ranges>
-#include <string>
-#include <stdexcept>
-#include <thread>
-
-namespace llmq {
-int16_t DEFAULT_WORKER_COUNT{std::clamp<int16_t>(std::thread::hardware_concurrency() / 2, 1, 4)};
-
-static bool EvalSpork(const Consensus::LLMQType llmqType, const int64_t spork_value)
-{
-    if (spork_value == 0) {
-        return true;
-    }
-    if (spork_value == 1 && llmqType != Consensus::LLMQType::LLMQ_100_67 && llmqType != Consensus::LLMQType::LLMQ_400_60 && llmqType != Consensus::LLMQType::LLMQ_400_85) {
-        return true;
-    }
-    return false;
-}
-
-bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
-{
-    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_21_QUORUM_ALL_CONNECTED));
-}
-
-bool IsQuorumDKGEnabled(const CSporkManager& sporkman) { return sporkman.IsSporkActive(SPORK_17_QUORUM_DKG_ENABLED); }
-
-bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
-{
-    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_23_QUORUM_POSE));
-}
-
-
-bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex)
-{
-    if (!llmqParams.useRotation) {
-        return false;
-    }
-
-    int cycleQuorumBaseHeight = pindex->nHeight - (pindex->nHeight % llmqParams.dkgInterval);
-    if (cycleQuorumBaseHeight < 1) {
-        return false;
-    }
-    // It should activate at least 1 block prior to the cycle start
-    return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0024);
-}
-
-QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args)
-{
-    QvvecSyncModeMap mapQuorumVvecSyncEntries;
-    for (const auto& strEntry : args.GetArgs("-llmq-qvvec-sync")) {
-        Consensus::LLMQType llmqType = Consensus::LLMQType::LLMQ_NONE;
-        QvvecSyncMode mode{QvvecSyncMode::Invalid};
-        std::istringstream ssEntry(strEntry);
-        std::string strLLMQType, strMode, strTest;
-        const bool fLLMQTypePresent = std::getline(ssEntry, strLLMQType, ':') && strLLMQType != "";
-        const bool fModePresent = std::getline(ssEntry, strMode, ':') && strMode != "";
-        const bool fTooManyEntries = static_cast<bool>(std::getline(ssEntry, strTest, ':'));
-        if (!fLLMQTypePresent || !fModePresent || fTooManyEntries) {
-            throw std::invalid_argument(strprintf("Invalid format in -llmq-qvvec-sync: %s", strEntry));
-        }
-
-        if (auto optLLMQParams = util::find_if_opt(Params().GetConsensus().llmqs, [&strLLMQType](const auto& params) {
-                return params.name == strLLMQType;
-            })) {
-            llmqType = optLLMQParams->type;
-        } else {
-            throw std::invalid_argument(strprintf("Invalid llmqType in -llmq-qvvec-sync: %s", strEntry));
-        }
-        if (mapQuorumVvecSyncEntries.count(llmqType) > 0) {
-            throw std::invalid_argument(strprintf("Duplicated llmqType in -llmq-qvvec-sync: %s", strEntry));
-        }
-
-        int32_t nMode;
-        if (ParseInt32(strMode, &nMode)) {
-            switch (nMode) {
-            case static_cast<int32_t>(QvvecSyncMode::Always):
-                mode = QvvecSyncMode::Always;
-                break;
-            case static_cast<int32_t>(QvvecSyncMode::OnlyIfTypeMember):
-                mode = QvvecSyncMode::OnlyIfTypeMember;
-                break;
-            default:
-                mode = QvvecSyncMode::Invalid;
-                break;
-            }
-        }
-        if (mode == QvvecSyncMode::Invalid) {
-            throw std::invalid_argument(strprintf("Invalid mode in -llmq-qvvec-sync: %s", strEntry));
-        }
-        mapQuorumVvecSyncEntries.emplace(llmqType, mode);
-    }
-    return mapQuorumVvecSyncEntries;
-}
-
-std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
-                                                       gsl::not_null<const CBlockIndex*> pindex)
-{
-    std::vector<Consensus::LLMQType> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-    for (const auto& params : Params().GetConsensus().llmqs) {
-        if (chainman.IsQuorumTypeEnabled(params.type, pindex)) {
-            ret.push_back(params.type);
-        }
-    }
-    return ret;
-}
-
-std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
-    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex)
-{
-    std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
-    ret.reserve(Params().GetConsensus().llmqs.size());
-
-    std::copy_if(Params().GetConsensus().llmqs.begin(), Params().GetConsensus().llmqs.end(), std::back_inserter(ret),
-                 [&pindex, &chainman](const auto& params) { return chainman.IsQuorumTypeEnabled(params.type, pindex); });
-
-    return ret;
-}
-} // namespace llmq
diff --git a/src/llmq/options_args.cpp b/src/llmq/options_args.cpp
new file mode 100644
index 000000000000..64cde1d67af1
--- /dev/null
+++ b/src/llmq/options_args.cpp
@@ -0,0 +1,66 @@
+// Copyright (c) 2014-2025 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <llmq/options_args.h>
+
+#include <chainparams.h>
+#include <common/args.h>
+#include <consensus/params.h>
+#include <tinyformat.h>
+#include <util/helpers.h>
+#include <util/strencodings.h>
+
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace llmq {
+QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args)
+{
+    QvvecSyncModeMap mapQuorumVvecSyncEntries;
+    for (const auto& strEntry : args.GetArgs("-llmq-qvvec-sync")) {
+        Consensus::LLMQType llmqType = Consensus::LLMQType::LLMQ_NONE;
+        QvvecSyncMode mode{QvvecSyncMode::Invalid};
+        std::istringstream ssEntry(strEntry);
+        std::string strLLMQType, strMode, strTest;
+        const bool fLLMQTypePresent = std::getline(ssEntry, strLLMQType, ':') && strLLMQType != "";
+        const bool fModePresent = std::getline(ssEntry, strMode, ':') && strMode != "";
+        const bool fTooManyEntries = static_cast<bool>(std::getline(ssEntry, strTest, ':'));
+        if (!fLLMQTypePresent || !fModePresent || fTooManyEntries) {
+            throw std::invalid_argument(strprintf("Invalid format in -llmq-qvvec-sync: %s", strEntry));
+        }
+
+        if (auto optLLMQParams = util::find_if_opt(Params().GetConsensus().llmqs, [&strLLMQType](const auto& params) {
+                return params.name == strLLMQType;
+            })) {
+            llmqType = optLLMQParams->type;
+        } else {
+            throw std::invalid_argument(strprintf("Invalid llmqType in -llmq-qvvec-sync: %s", strEntry));
+        }
+        if (mapQuorumVvecSyncEntries.count(llmqType) > 0) {
+            throw std::invalid_argument(strprintf("Duplicated llmqType in -llmq-qvvec-sync: %s", strEntry));
+        }
+
+        int32_t nMode;
+        if (ParseInt32(strMode, &nMode)) {
+            switch (nMode) {
+            case static_cast<int32_t>(QvvecSyncMode::Always):
+                mode = QvvecSyncMode::Always;
+                break;
+            case static_cast<int32_t>(QvvecSyncMode::OnlyIfTypeMember):
+                mode = QvvecSyncMode::OnlyIfTypeMember;
+                break;
+            default:
+                mode = QvvecSyncMode::Invalid;
+                break;
+            }
+        }
+        if (mode == QvvecSyncMode::Invalid) {
+            throw std::invalid_argument(strprintf("Invalid mode in -llmq-qvvec-sync: %s", strEntry));
+        }
+        mapQuorumVvecSyncEntries.emplace(llmqType, mode);
+    }
+    return mapQuorumVvecSyncEntries;
+}
+} // namespace llmq
diff --git a/src/llmq/options.h b/src/llmq/options_args.h
similarity index 55%
rename from src/llmq/options.h
rename to src/llmq/options_args.h
index 8bb0b22b1f06..abc53b2c4d86 100644
--- a/src/llmq/options.h
+++ b/src/llmq/options_args.h
@@ -1,22 +1,17 @@
-// Copyright (c) 2018-2025 The Dash Core developers
+// Copyright (c) 2014-2025 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_LLMQ_OPTIONS_H
-#define BITCOIN_LLMQ_OPTIONS_H
-
-#include <gsl/pointers.h>
+#ifndef BITCOIN_LLMQ_OPTIONS_ARGS_H
+#define BITCOIN_LLMQ_OPTIONS_ARGS_H
 
+#include <algorithm>
+#include <cstdint>
 #include <map>
-#include <optional>
-#include <vector>
+#include <thread>
 
 class ArgsManager;
-class CBlockIndex;
-class ChainstateManager;
-class CSporkManager;
 namespace Consensus {
-struct LLMQParams;
 enum class LLMQType : uint8_t;
 } // namespace Consensus
 
@@ -37,23 +32,14 @@ static constexpr bool DEFAULT_WATCH_QUORUMS{false};
 /** -parbls default (number of bls-checking threads, 0 = auto) */
 static constexpr int8_t DEFAULT_BLSCHECK_THREADS{0};
 /** Number of workers allocated per worker pool */
-extern int16_t DEFAULT_WORKER_COUNT;
+inline const int16_t DEFAULT_WORKER_COUNT{std::clamp<int16_t>(std::thread::hardware_concurrency() / 2, 1, 4)};
 /** Maximum number of dedicated script-checking threads allowed */
 static constexpr int8_t MAX_BLSCHECK_THREADS{33};
 
-bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
-bool IsQuorumDKGEnabled(const CSporkManager& sporkman);
-bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
-bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
+using QvvecSyncModeMap = std::map<Consensus::LLMQType, QvvecSyncMode>;
 
 /// Returns the parsed entries given by `-llmq-qvvec-sync`
-using QvvecSyncModeMap = std::map<Consensus::LLMQType, QvvecSyncMode>;
 QvvecSyncModeMap GetEnabledQuorumVvecSyncEntries(const ArgsManager& args);
-
-std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
-                                                       gsl::not_null<const CBlockIndex*> pindex);
-std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
-    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex);
 } // namespace llmq
 
-#endif // BITCOIN_LLMQ_OPTIONS_H
+#endif // BITCOIN_LLMQ_OPTIONS_ARGS_H
diff --git a/src/llmq/quorumsman.cpp b/src/llmq/quorumsman.cpp
index 6e370e9a9846..48a8fd5bbcdf 100644
--- a/src/llmq/quorumsman.cpp
+++ b/src/llmq/quorumsman.cpp
@@ -11,7 +11,6 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/dkgsessionmgr.h>
-#include <llmq/options.h>
 #include <llmq/params.h>
 #include <llmq/signhash.h>
 #include <llmq/utils.h>
@@ -77,7 +76,7 @@ CQuorumPtr CQuorumManager::BuildQuorumFromCommitment(const Consensus::LLMQType l
     }
     assert(qc.quorumHash == pQuorumBaseBlockIndex->GetBlockHash());
 
-    const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
     auto members = utils::GetAllQuorumMembers(qc.llmqType, {m_dmnman, m_qsnapman, m_chainman, pQuorumBaseBlockIndex});
 
@@ -199,7 +198,7 @@ std::vector<T> CQuorumManager::ScanMined(Consensus::LLMQType llmqType, gsl::not_
     }
 
     gsl::not_null<const CBlockIndex*> pindexStore{pindexStart};
-    const auto& llmq_params_opt = Params().GetLLMQ(llmqType);
+    const auto& llmq_params_opt = m_chainman.GetParams().GetLLMQ(llmqType);
     assert(llmq_params_opt.has_value());
 
     // Quorum sets can only change during the mining phase of DKG.
@@ -233,7 +232,7 @@ std::vector<T> CQuorumManager::ScanMined(Consensus::LLMQType llmqType, gsl::not_
             // And we only do this for max_cycles() of the most recent quorums
             // because signing by old quorums requires the exact quorum hash to be specified
             // and quorum scanning isn't needed there.
-            cache.Init(Params().GetConsensus(), [](const Consensus::LLMQParams& llmq) {
+            cache.Init(m_chainman.GetConsensus(), [](const Consensus::LLMQParams& llmq) {
                 return llmq.max_cycles(llmq.keepOldConnections) * (llmq.dkgMiningWindowEnd - llmq.dkgMiningWindowStart);
             });
         }
diff --git a/src/llmq/signing_shares.cpp b/src/llmq/signing_shares.cpp
index 5dd6ce91a3bc..5aa2df60dea1 100644
--- a/src/llmq/signing_shares.cpp
+++ b/src/llmq/signing_shares.cpp
@@ -8,11 +8,11 @@
 #include <chainparams.h>
 #include <evo/deterministicmns.h>
 #include <llmq/commitment.h>
-#include <llmq/options.h>
 #include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
+#include <llmq/utils.h>
 #include <netmessagemaker.h>
 #include <util/helpers.h>
 #include <util/std23.h>
diff --git a/src/llmq/utils.cpp b/src/llmq/utils.cpp
index 0d34b0c43dcf..541de71ed982 100644
--- a/src/llmq/utils.cpp
+++ b/src/llmq/utils.cpp
@@ -7,10 +7,10 @@
 #include <bls/bls.h>
 #include <evo/deterministicmns.h>
 #include <llmq/cache.h>
-#include <llmq/options.h>
 #include <llmq/snapshot.h>
 #include <llmq/types.h>
 #include <masternode/meta.h>
+#include <spork.h>
 #include <util/helpers.h>
 #include <util/std23.h>
 
@@ -20,7 +20,9 @@
 #include <util/time.h>
 #include <validation.h>
 
+#include <algorithm>
 #include <atomic>
+#include <iterator>
 #include <map>
 #include <optional>
 
@@ -547,6 +549,70 @@ std::vector<QuorumMembers> ComputeQuorumMembersByQuarterRotation(const Consensus
 } // anonymous namespace
 
 namespace llmq {
+static bool EvalSpork(const Consensus::LLMQType llmqType, const int64_t spork_value)
+{
+    if (spork_value == 0) {
+        return true;
+    }
+    if (spork_value == 1 && llmqType != Consensus::LLMQType::LLMQ_100_67 &&
+        llmqType != Consensus::LLMQType::LLMQ_400_60 && llmqType != Consensus::LLMQType::LLMQ_400_85) {
+        return true;
+    }
+    return false;
+}
+
+bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
+{
+    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_21_QUORUM_ALL_CONNECTED));
+}
+
+bool IsQuorumDKGEnabled(const CSporkManager& sporkman) { return sporkman.IsSporkActive(SPORK_17_QUORUM_DKG_ENABLED); }
+
+bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman)
+{
+    return EvalSpork(llmqType, sporkman.GetSporkValue(SPORK_23_QUORUM_POSE));
+}
+
+bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex)
+{
+    if (!llmqParams.useRotation) {
+        return false;
+    }
+
+    int cycleQuorumBaseHeight = pindex->nHeight - (pindex->nHeight % llmqParams.dkgInterval);
+    if (cycleQuorumBaseHeight < 1) {
+        return false;
+    }
+    // It should activate at least 1 block prior to the cycle start
+    return DeploymentActiveAfter(pindex->GetAncestor(cycleQuorumBaseHeight - 1), Params().GetConsensus(),
+                                 Consensus::DEPLOYMENT_DIP0024);
+}
+
+std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
+                                                       gsl::not_null<const CBlockIndex*> pindex)
+{
+    std::vector<Consensus::LLMQType> ret;
+    ret.reserve(chainman.GetConsensus().llmqs.size());
+    for (const auto& params : chainman.GetConsensus().llmqs) {
+        if (chainman.IsQuorumTypeEnabled(params.type, pindex)) {
+            ret.push_back(params.type);
+        }
+    }
+    return ret;
+}
+
+std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
+    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex)
+{
+    std::vector<std::reference_wrapper<const Consensus::LLMQParams>> ret;
+    ret.reserve(chainman.GetConsensus().llmqs.size());
+
+    std::copy_if(chainman.GetConsensus().llmqs.begin(), chainman.GetConsensus().llmqs.end(), std::back_inserter(ret),
+                 [&pindex, &chainman](const auto& params) { return chainman.IsQuorumTypeEnabled(params.type, pindex); });
+
+    return ret;
+}
+
 namespace utils {
 BlsCheck::BlsCheck() = default;
 
diff --git a/src/llmq/utils.h b/src/llmq/utils.h
index 65c4c2682808..b471c084a767 100644
--- a/src/llmq/utils.h
+++ b/src/llmq/utils.h
@@ -16,6 +16,7 @@
 
 #include <gsl/pointers.h>
 
+#include <functional>
 #include <optional>
 #include <unordered_set>
 #include <vector>
@@ -42,6 +43,16 @@ struct UtilParameters {
     }
 };
 
+bool IsAllMembersConnectedEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
+bool IsQuorumDKGEnabled(const CSporkManager& sporkman);
+bool IsQuorumPoseEnabled(const Consensus::LLMQType llmqType, const CSporkManager& sporkman);
+bool IsQuorumRotationEnabled(const Consensus::LLMQParams& llmqParams, gsl::not_null<const CBlockIndex*> pindex);
+
+std::vector<Consensus::LLMQType> GetEnabledQuorumTypes(const ChainstateManager& chainman,
+                                                       gsl::not_null<const CBlockIndex*> pindex);
+std::vector<std::reference_wrapper<const Consensus::LLMQParams>> GetEnabledQuorumParams(
+    const ChainstateManager& chainman, gsl::not_null<const CBlockIndex*> pindex);
+
 namespace utils {
 struct BlsCheck {
     CBLSSignature m_sig;
diff --git a/src/masternode/meta.cpp b/src/masternode/meta.cpp
index c9c3934c4d4a..c995ac8e718f 100644
--- a/src/masternode/meta.cpp
+++ b/src/masternode/meta.cpp
@@ -18,8 +18,8 @@ namespace {
 static const CMasternodeMetaInfo default_meta_info{};
 } // anonymous namespace
 
-CMasternodeMetaMan::CMasternodeMetaMan() :
-    m_db{std::make_unique<db_type>("mncache.dat", "magicMasternodeCache")}
+CMasternodeMetaMan::CMasternodeMetaMan(const fs::path& data_dir) :
+    m_db{std::make_unique<db_type>(data_dir, "mncache.dat", "magicMasternodeCache")}
 {
 }
 
diff --git a/src/masternode/meta.h b/src/masternode/meta.h
index 535a721e586f..3301e4740299 100644
--- a/src/masternode/meta.h
+++ b/src/masternode/meta.h
@@ -12,6 +12,7 @@
 #include <threadsafety.h>
 #include <uint256.h>
 #include <unordered_lru_cache.h>
+#include <util/fs.h>
 
 #include <deque>
 #include <map>
@@ -205,7 +206,7 @@ class CMasternodeMetaMan : public MasternodeMetaStore
 public:
     CMasternodeMetaMan(const CMasternodeMetaMan&) = delete;
     CMasternodeMetaMan& operator=(const CMasternodeMetaMan&) = delete;
-    CMasternodeMetaMan();
+    explicit CMasternodeMetaMan(const fs::path& data_dir);
     ~CMasternodeMetaMan();
 
     bool LoadCache(bool load_cache);
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
index 10ae4ebe2874..dd68b49cd611 100644
--- a/src/net_processing.cpp
+++ b/src/net_processing.cpp
@@ -57,7 +57,6 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/quorumsman.h>
 #include <llmq/signhash.h>
 #include <llmq/signing.h>
@@ -4249,7 +4248,7 @@ void PeerManagerImpl::ProcessMessage(
         if (!pfrom.IsInboundConn()) {
             // Don't use timedata samples from inbound peers to make it
             // harder for others to tamper with our adjusted time.
-            AddTimeData(pfrom.addr, nTimeOffset);
+            AddTimeData(pfrom.addr, nTimeOffset, m_opts.max_time_adjustment);
         }
 
         // Feeler connections exist only to verify if address is online.
diff --git a/src/net_processing.h b/src/net_processing.h
index d83a30d0f493..5f4bc83c80ed 100644
--- a/src/net_processing.h
+++ b/src/net_processing.h
@@ -7,6 +7,7 @@
 #define BITCOIN_NET_PROCESSING_H
 
 #include <net.h>
+#include <timedata.h>
 #include <validationinterface.h>
 #include <version.h>
 
@@ -174,6 +175,8 @@ class PeerManager : public CValidationInterface, public NetEventsInterface, publ
         //! Whether or not the internal RNG behaves deterministically (this is
         //! a test-only option).
         bool deterministic_rng{false};
+        //! Maximum allowed median peer time offset adjustment, in seconds
+        int64_t max_time_adjustment{DEFAULT_MAX_TIME_ADJUSTMENT};
     };
 
     /**
diff --git a/src/netfulfilledman.cpp b/src/netfulfilledman.cpp
index 43b981405911..e4f1c6ee180f 100644
--- a/src/netfulfilledman.cpp
+++ b/src/netfulfilledman.cpp
@@ -7,8 +7,8 @@
 #include <netfulfilledman.h>
 #include <shutdown.h>
 
-CNetFulfilledRequestManager::CNetFulfilledRequestManager() :
-    m_db{std::make_unique<db_type>("netfulfilled.dat", "magicFulfilledCache")}
+CNetFulfilledRequestManager::CNetFulfilledRequestManager(const fs::path& data_dir) :
+    m_db{std::make_unique<db_type>(data_dir, "netfulfilled.dat", "magicFulfilledCache")}
 {
 }
 
diff --git a/src/netfulfilledman.h b/src/netfulfilledman.h
index e8e9b98994c4..2cd60af7cf6a 100644
--- a/src/netfulfilledman.h
+++ b/src/netfulfilledman.h
@@ -8,6 +8,7 @@
 #include <netaddress.h>
 #include <serialize.h>
 #include <sync.h>
+#include <util/fs.h>
 
 #include <memory>
 
@@ -52,7 +53,7 @@ class CNetFulfilledRequestManager : public NetFulfilledRequestStore
 public:
     CNetFulfilledRequestManager(const CNetFulfilledRequestManager&) = delete;
     CNetFulfilledRequestManager& operator=(const CNetFulfilledRequestManager&) = delete;
-    CNetFulfilledRequestManager();
+    explicit CNetFulfilledRequestManager(const fs::path& data_dir);
     ~CNetFulfilledRequestManager();
 
     bool LoadCache(bool load_cache);
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
index 5bb1e99fe34c..f22bc434209f 100644
--- a/src/node/blockstorage.cpp
+++ b/src/node/blockstorage.cpp
@@ -398,12 +398,6 @@ bool BlockManager::LoadBlockIndexDB()
     m_block_tree_db->ReadReindexing(fReindexing);
     if (fReindexing) fReindex = true;
 
-    // Migrate old synchronous index data from block index database
-    // to async indexes in separate databases
-    if (!m_block_tree_db->MigrateOldIndexData()) {
-        return false;
-    }
-
     return true;
 }
 
diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp
index ea001791d571..302f17efc32d 100644
--- a/src/node/chainstate.cpp
+++ b/src/node/chainstate.cpp
@@ -174,6 +174,12 @@ static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager&
         return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
     }
 
+    // Migrate old synchronous index data from block index database
+    // to async indexes in separate databases
+    if (!options.reindex && !chainman.m_blockman.m_block_tree_db->MigrateOldIndexData(options.data_dir, options.index_migration)) {
+        return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
+    }
+
     if (!chainman.BlockIndex().empty() &&
             !chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
         // If the loaded chain has a wrong genesis, bail out immediately
diff --git a/src/node/chainstate.h b/src/node/chainstate.h
index 1a5b63b03a28..5255711ffdc8 100644
--- a/src/node/chainstate.h
+++ b/src/node/chainstate.h
@@ -33,6 +33,7 @@ struct ChainstateLoadOptions {
     llmq::CInstantSendManager* isman{nullptr};
     chainlock::Chainlocks* chainlocks{nullptr};
     fs::path data_dir;
+    IndexMigrationOptions index_migration;
 
     bool block_tree_db_in_memory{false};
     bool coins_db_in_memory{false};
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index a12196d561e9..a821835674ea 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -36,9 +36,9 @@
 #include <llmq/blockprocessor.h>
 #include <llmq/commitment.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
+#include <llmq/utils.h>
 #include <logging.h>
 #include <mapport.h>
 #include <masternode/sync.h>
diff --git a/src/node/kernel_notifications.cpp b/src/node/kernel_notifications.cpp
index f9010a065133..cf73279c10ca 100644
--- a/src/node/kernel_notifications.cpp
+++ b/src/node/kernel_notifications.cpp
@@ -72,4 +72,9 @@ void KernelNotifications::warning(const bilingual_str& warning)
     DoWarning(warning);
 }
 
+void KernelNotifications::masternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* index)
+{
+    uiInterface.NotifyMasternodeListChanged(list, index);
+}
+
 } // namespace node
diff --git a/src/node/kernel_notifications.h b/src/node/kernel_notifications.h
index 3e665bbf14e5..f1591f13825f 100644
--- a/src/node/kernel_notifications.h
+++ b/src/node/kernel_notifications.h
@@ -11,6 +11,7 @@
 #include <string>
 
 class CBlockIndex;
+class CDeterministicMNList;
 enum class SynchronizationState;
 struct bilingual_str;
 
@@ -25,6 +26,8 @@ class KernelNotifications : public kernel::Notifications
     void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override;
 
     void warning(const bilingual_str& warning) override;
+
+    void masternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* index) override;
 };
 } // namespace node
 
diff --git a/src/node/miner.cpp b/src/node/miner.cpp
index ca84a4b531da..1def21c59a01 100644
--- a/src/node/miner.cpp
+++ b/src/node/miner.cpp
@@ -38,8 +38,8 @@
 #include <instantsend/instantsend.h>
 #include <llmq/blockprocessor.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/snapshot.h>
+#include <llmq/utils.h>
 #include <masternode/payments.h>
 
 #include <algorithm>
diff --git a/src/node/peerman_args.cpp b/src/node/peerman_args.cpp
index 205507dcb385..c3cdbcc44b06 100644
--- a/src/node/peerman_args.cpp
+++ b/src/node/peerman_args.cpp
@@ -21,6 +21,8 @@ void ApplyArgsManOptions(const ArgsManager& argsman, PeerManager::Options& optio
     }
 
     if (auto value{argsman.GetBoolArg("-capturemessages")}) options.capture_messages = *value;
+
+    if (auto value{argsman.GetIntArg("-maxtimeadjustment")}) options.max_time_adjustment = *value;
 }
 
 } // namespace node
diff --git a/src/rpc/quorums.cpp b/src/rpc/quorums.cpp
index 3d211138d3ea..afa56484bd37 100644
--- a/src/rpc/quorums.cpp
+++ b/src/rpc/quorums.cpp
@@ -15,7 +15,6 @@
 #include <llmq/dkgsession.h>
 #include <llmq/dkgsessionhandler.h>
 #include <llmq/observer.h>
-#include <llmq/options.h>
 #include <llmq/quorumproofs.h>
 #include <evo/simplifiedmns.h>
 #include <clientversion.h>
diff --git a/src/spork.cpp b/src/spork.cpp
index 0559972311de..8357933d4e08 100644
--- a/src/spork.cpp
+++ b/src/spork.cpp
@@ -37,8 +37,8 @@ void SporkStore::Clear()
     // we should not alter them here.
 }
 
-CSporkManager::CSporkManager() :
-    m_db{std::make_unique<db_type>("sporks.dat", "magicSporkCache")}
+CSporkManager::CSporkManager(const fs::path& data_dir) :
+    m_db{std::make_unique<db_type>(data_dir, "sporks.dat", "magicSporkCache")}
 {
 }
 
diff --git a/src/spork.h b/src/spork.h
index fef50b497cc1..5d02cd0e4ec2 100644
--- a/src/spork.h
+++ b/src/spork.h
@@ -10,6 +10,7 @@
 #include <pubkey.h>
 #include <saltedhasher.h>
 #include <sync.h>
+#include <util/fs.h>
 #include <util/time.h>
 
 #include <array>
@@ -203,7 +204,7 @@ class CSporkManager : public SporkStore
 public:
     CSporkManager(const CSporkManager&) = delete;
     CSporkManager& operator=(const CSporkManager&) = delete;
-    CSporkManager();
+    explicit CSporkManager(const fs::path& data_dir);
     ~CSporkManager();
 
     bool LoadCache();
diff --git a/src/test/evo_utils_tests.cpp b/src/test/evo_utils_tests.cpp
index 4f70b0024821..4488edcf2e08 100644
--- a/src/test/evo_utils_tests.cpp
+++ b/src/test/evo_utils_tests.cpp
@@ -6,7 +6,6 @@
 
 #include <chainparams.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
 #include <llmq/utils.h>
 #include <validation.h>
 
diff --git a/src/test/governance_inv_tests.cpp b/src/test/governance_inv_tests.cpp
index f1b21d04775f..d65925d737a7 100644
--- a/src/test/governance_inv_tests.cpp
+++ b/src/test/governance_inv_tests.cpp
@@ -60,8 +60,9 @@ struct GovernanceInvSetup : public TestingSetup {
         // Note: mn_metaman is left unloaded. Reaching CGovernanceObject::ProcessVote asserts
         // metaman.IsValid(), so a test that delivers a vote whose parent object exists must
         // load it first (see invalid_vote_is_scored_alike_with_and_without_a_parent_object).
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.sbman,
-                                                             *m_node.dmnman, *m_node.mn_sync, &m_collateral);
+        m_node.govman = std::make_unique<CGovernanceManager>(m_args.GetDataDirNet(), *m_node.mn_metaman,
+                                                             *m_node.chainman, *m_node.sbman, *m_node.dmnman,
+                                                             *m_node.mn_sync, &m_collateral);
         // Match runtime preconditions: NetGovernance::AlreadyHave claims we
         // already have the inv when governance isn't loaded (e.g.
         // -disablegovernance), so ConfirmInventoryRequest would never run.
diff --git a/src/test/governance_vote_processing_tests.cpp b/src/test/governance_vote_processing_tests.cpp
index 171c0708be78..2b2f6f28bfb3 100644
--- a/src/test/governance_vote_processing_tests.cpp
+++ b/src/test/governance_vote_processing_tests.cpp
@@ -132,9 +132,9 @@ struct GovernanceVoteSetup : public TestChainSetup {
         }
         BOOST_REQUIRE(m_node.mn_sync->IsSynced());
 
-        m_node.govman = std::make_unique<CGovernanceManager>(*m_node.mn_metaman, *m_node.chainman, *m_node.sbman,
-                                                             *m_node.dmnman, *m_node.mn_sync,
-                                                             m_node.gov_collateral_index.get());
+        m_node.govman = std::make_unique<CGovernanceManager>(m_args.GetDataDirNet(), *m_node.mn_metaman,
+                                                             *m_node.chainman, *m_node.sbman, *m_node.dmnman,
+                                                             *m_node.mn_sync, m_node.gov_collateral_index.get());
         BOOST_REQUIRE(m_node.govman->LoadCache(/*load_cache=*/false));
 
         proposal_time = TicksSinceEpoch<std::chrono::seconds>(GetAdjustedTime());
diff --git a/src/test/governance_vote_sync_tests.cpp b/src/test/governance_vote_sync_tests.cpp
index 3729efc24f7f..d0dc8f641130 100644
--- a/src/test/governance_vote_sync_tests.cpp
+++ b/src/test/governance_vote_sync_tests.cpp
@@ -56,7 +56,7 @@ BOOST_AUTO_TEST_CASE(fulfilled_request_manager_is_port_sensitive)
     const CService peer_a{CNetAddr{ipv4}, /*port=*/40000};
     const CService peer_b{CNetAddr{ipv4}, /*port=*/40001};
 
-    CNetFulfilledRequestManager fulfilled;
+    CNetFulfilledRequestManager fulfilled{m_args.GetDataDirNet()};
     BOOST_REQUIRE(fulfilled.LoadCache(/*load_cache=*/false));
 
     const std::string request{"mngovernancesync-votes-deadbeef"};
diff --git a/src/test/index_migration_tests.cpp b/src/test/index_migration_tests.cpp
index bcf9250b50d5..09675d8277c3 100644
--- a/src/test/index_migration_tests.cpp
+++ b/src/test/index_migration_tests.cpp
@@ -57,7 +57,8 @@ BOOST_FIXTURE_TEST_CASE(empty_index_is_not_adopted_as_migrated, IndexMigrationSe
     CBlockTreeDB& block_tree_db{*WITH_LOCK(cs_main, return m_node.chainman->m_blockman.m_block_tree_db.get())};
     BOOST_REQUIRE(block_tree_db.WriteFlag("timestampindex", true));
 
-    BOOST_REQUIRE(WITH_LOCK(cs_main, return block_tree_db.MigrateOldIndexData()));
+    BOOST_REQUIRE(
+        WITH_LOCK(cs_main, return block_tree_db.MigrateOldIndexData(gArgs.GetDataDirNet(), {.timestamp_index = true})));
 
     BOOST_CHECK_EQUAL(LoadedTimestampIndexHeight(), 0);
     // The legacy entries are gone, so older versions must not trust their synchronous index either.
diff --git a/src/test/llmq_qgetdata_tests.cpp b/src/test/llmq_qgetdata_tests.cpp
index 65a0527c30d2..14d9eb45e1ac 100644
--- a/src/test/llmq_qgetdata_tests.cpp
+++ b/src/test/llmq_qgetdata_tests.cpp
@@ -5,7 +5,7 @@
 #include <arith_uint256.h>
 #include <llmq/context.h>
 #include <llmq/net_quorum.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/quorums.h>
 #include <llmq/quorumsman.h>
 #include <net.h>
diff --git a/src/test/spork_tests.cpp b/src/test/spork_tests.cpp
index 94f9cebe5c93..e2ca5b12e32a 100644
--- a/src/test/spork_tests.cpp
+++ b/src/test/spork_tests.cpp
@@ -19,7 +19,7 @@ BOOST_FIXTURE_TEST_SUITE(spork_tests, RegTestingSetup)
 
 BOOST_AUTO_TEST_CASE(extreme_timestamps_are_handled_without_overflow)
 {
-    CSporkManager sporkman;
+    CSporkManager sporkman{m_args.GetDataDirNet()};
     CKey key;
     key.MakeNewKey(/*fCompressed=*/true);
     BOOST_REQUIRE(sporkman.SetSporkAddress(EncodeDestination(PKHash{key.GetPubKey()})));
@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(extreme_timestamps_are_handled_without_overflow)
 
 BOOST_AUTO_TEST_CASE(sporks_signed_by_an_unknown_key_are_rejected)
 {
-    CSporkManager sporkman;
+    CSporkManager sporkman{m_args.GetDataDirNet()};
     CKey spork_key;
     spork_key.MakeNewKey(/*fCompressed=*/true);
     BOOST_REQUIRE(sporkman.SetSporkAddress(EncodeDestination(PKHash{spork_key.GetPubKey()})));
@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(sporks_signed_by_an_unknown_key_are_rejected)
 
 BOOST_AUTO_TEST_CASE(check_and_remove_drops_sporks_not_signed_by_the_spork_key)
 {
-    CSporkManager sporkman;
+    CSporkManager sporkman{m_args.GetDataDirNet()};
     CKey key;
     key.MakeNewKey(/*fCompressed=*/true);
     BOOST_REQUIRE(sporkman.SetSporkAddress(EncodeDestination(PKHash{key.GetPubKey()})));
diff --git a/src/test/timedata_tests.cpp b/src/test/timedata_tests.cpp
index 2814dbf4c06a..d8063c45002c 100644
--- a/src/test/timedata_tests.cpp
+++ b/src/test/timedata_tests.cpp
@@ -49,7 +49,7 @@ static void MultiAddTimeData(int n, int64_t offset)
     for (int i = 0; i < n; ++i) {
         CNetAddr addr;
         addr.SetInternal(ToString(++cnt));
-        AddTimeData(addr, offset);
+        AddTimeData(addr, offset, DEFAULT_MAX_TIME_ADJUSTMENT);
     }
 }
 
diff --git a/src/test/util/setup_common.cpp b/src/test/util/setup_common.cpp
index d50805fabf68..dccfbefccd41 100644
--- a/src/test/util/setup_common.cpp
+++ b/src/test/util/setup_common.cpp
@@ -23,6 +23,9 @@
 #include <consensus/validation.h>
 #include <deploymentstatus.h>
 #include <crypto/sha256.h>
+#include <index/addressindex.h>
+#include <index/spentindex.h>
+#include <index/timestampindex.h>
 #include <index/txindex.h>
 #include <init.h>
 #include <init/common.h>
@@ -87,7 +90,7 @@
 #include <governance/superblock.h>
 #include <instantsend/instantsend.h>
 #include <llmq/context.h>
-#include <llmq/options.h>
+#include <llmq/options_args.h>
 #include <llmq/signing.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
@@ -217,9 +220,9 @@ BasicTestingSetup::BasicTestingSetup(const ChainType chainType, const std::vecto
 
     m_node.connman = std::make_unique<ConnmanTestMsg>(0x1337, 0x1337, *m_node.addrman, *m_node.netgroupman); // Deterministic randomness for tests.
 
-    m_node.mn_metaman = std::make_unique<CMasternodeMetaMan>();
-    m_node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>();
-    m_node.sporkman = std::make_unique<CSporkManager>();
+    m_node.mn_metaman = std::make_unique<CMasternodeMetaMan>(m_args.GetDataDirNet());
+    m_node.netfulfilledman = std::make_unique<CNetFulfilledRequestManager>(m_args.GetDataDirNet());
+    m_node.sporkman = std::make_unique<CSporkManager>(m_args.GetDataDirNet());
     m_node.chainlocks = std::make_unique<chainlock::Chainlocks>(*m_node.sporkman);
     m_node.sbman = std::make_unique<governance::SuperblockManager>();
     m_node.mn_sync = std::make_unique<CMasternodeSync>(std::make_unique<NodeSyncNotifierImpl>(*m_node.connman, *m_node.netfulfilledman));
@@ -323,6 +326,9 @@ node::ChainstateLoadOptions ChainTestingSetup::ChainstateLoadOptionsForTest()
     options.isman = Assert(m_node.isman.get());
     options.chainlocks = Assert(m_node.chainlocks.get());
     options.data_dir = Assert(m_node.args)->GetDataDirNet();
+    options.index_migration.address_index = Assert(m_node.args)->GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX);
+    options.index_migration.spent_index = Assert(m_node.args)->GetBoolArg("-spentindex", DEFAULT_SPENTINDEX);
+    options.index_migration.timestamp_index = Assert(m_node.args)->GetBoolArg("-timestampindex", DEFAULT_TIMESTAMPINDEX);
     options.block_tree_db_in_memory = m_block_tree_db_in_memory;
     options.coins_db_in_memory = m_coins_db_in_memory;
     options.dash_dbs_in_memory = m_dash_dbs_in_memory;
diff --git a/src/timedata.cpp b/src/timedata.cpp
index 15ca90ee6a05..7453818420b2 100644
--- a/src/timedata.cpp
+++ b/src/timedata.cpp
@@ -8,7 +8,6 @@
 
 #include <timedata.h>
 
-#include <common/args.h>
 #include <logging.h>
 #include <netaddress.h>
 #include <node/interface_ui.h>
@@ -44,7 +43,7 @@ static std::set<CNetAddr> g_sources;
 static CMedianFilter<int64_t> g_time_offsets{BITCOIN_TIMEDATA_MAX_SAMPLES, 0};
 static bool g_warning_emitted;
 
-void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)
+void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample, int64_t max_adjustment)
 {
     LOCK(g_timeoffset_mutex);
     // Ignore duplicates
@@ -78,7 +77,7 @@ void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)
         int64_t nMedian = g_time_offsets.median();
         std::vector<int64_t> vSorted = g_time_offsets.sorted();
         // Only let other nodes change our time by so much
-        int64_t max_adjustment = std::max<int64_t>(0, gArgs.GetIntArg("-maxtimeadjustment", DEFAULT_MAX_TIME_ADJUSTMENT));
+        max_adjustment = std::max<int64_t>(0, max_adjustment);
         if (nMedian >= -max_adjustment && nMedian <= max_adjustment) {
             nTimeOffset = nMedian;
         } else {
diff --git a/src/timedata.h b/src/timedata.h
index c6c36d9a3970..9f52d8d4d01b 100644
--- a/src/timedata.h
+++ b/src/timedata.h
@@ -76,7 +76,7 @@ class CMedianFilter
 /** Functions to keep track of adjusted P2P time */
 int64_t GetTimeOffset();
 NodeClock::time_point GetAdjustedTime();
-void AddTimeData(const CNetAddr& ip, int64_t nTime);
+void AddTimeData(const CNetAddr& ip, int64_t nTime, int64_t max_adjustment);
 
 /**
  * Reset the internal state of GetTimeOffset(), GetAdjustedTime() and AddTimeData().
diff --git a/src/txdb.cpp b/src/txdb.cpp
index 0a2a6b1a7edc..855f4ee00e75 100644
--- a/src/txdb.cpp
+++ b/src/txdb.cpp
@@ -7,7 +7,6 @@
 #include <txdb.h>
 
 #include <chain.h>
-#include <common/args.h>
 #include <index/addressindex_types.h>
 #include <index/spentindex_types.h>
 #include <index/timestampindex_types.h>
@@ -488,18 +487,17 @@ static bool TargetNeedsLocator(CDBWrapper& target_db)
     return !target_db.IsEmpty();
 }
 
-bool CBlockTreeDB::MigrateOldIndexData()
+bool CBlockTreeDB::MigrateOldIndexData(const fs::path& data_dir, const IndexMigrationOptions& options)
 {
     // Migrate old synchronous index data that was stored in the block index database
     // to new async indexes in separate databases under indexes/{timestampindex,spentindex,addressindex}/
     // This preserves existing index data so users don't need to rebuild.
     // Indexes are migrated independently since they can be enabled individually.
 
-    // Only migrate indexes that are actually enabled via command-line flags
-    // NOTE: not using DEFAULT_* constants here to avoid circular dependencies
-    const bool fTimestampIndex = gArgs.GetBoolArg("-timestampindex", false);
-    const bool fSpentIndex = gArgs.GetBoolArg("-spentindex", false);
-    const bool fAddressIndex = gArgs.GetBoolArg("-addressindex", false);
+    // Only migrate indexes that are actually enabled
+    const bool fTimestampIndex = options.timestamp_index;
+    const bool fSpentIndex = options.spent_index;
+    const bool fAddressIndex = options.address_index;
 
     // The flags read below say whether the legacy rows still cover the chain tip. Nothing
     // maintains those rows any more, so a disabled index falls behind from this run on:
@@ -532,15 +530,15 @@ bool CBlockTreeDB::MigrateOldIndexData()
     const bool spentindex_was_current     = ReadFlag("spentindex",     legacy_flag) && legacy_flag;
     const bool timestampindex_was_current = ReadFlag("timestampindex", legacy_flag) && legacy_flag;
 
-    size_t batch_size = (size_t)gArgs.GetIntArg("-dbbatchsize", nDefaultDbBatchSize);
+    const size_t batch_size = options.batch_size;
     size_t total_count = 0;
-    const fs::path indexes_path = gArgs.GetDataDirNet() / "indexes";
+    const fs::path indexes_path = data_dir / "indexes";
 
     // Read the best block hash from coins database to set as best block for migrated indexes
     // Old synchronous indexes were updated during ConnectBlock, so they're synced to the active chain tip
     uint256 best_block_hash;
     {
-        fs::path chainstate_path = gArgs.GetDataDirNet() / "chainstate";
+        fs::path chainstate_path = data_dir / "chainstate";
         CDBWrapper coins_db{DBParams{.path = chainstate_path, .cache_bytes = 0}};
         if (!coins_db.Read(DB_BEST_BLOCK, best_block_hash)) {
             // If we can't read the best block, the indexes will resync from scratch
diff --git a/src/txdb.h b/src/txdb.h
index b4ea64a07147..cbe025066bdc 100644
--- a/src/txdb.h
+++ b/src/txdb.h
@@ -31,6 +31,14 @@ struct bilingual_str;
 static const int64_t nDefaultDbCache = 300;
 //! -dbbatchsize default (bytes)
 static const int64_t nDefaultDbBatchSize = 16 << 20;
+
+//! Which legacy synchronous indexes CBlockTreeDB::MigrateOldIndexData() carries over
+struct IndexMigrationOptions {
+    bool address_index{false};
+    bool spent_index{false};
+    bool timestamp_index{false};
+    size_t batch_size{nDefaultDbBatchSize};
+};
 //! max. -dbcache (MiB)
 static const int64_t nMaxDbCache = sizeof(void*) > 4 ? 16384 : 1024;
 //! min. -dbcache (MiB)
@@ -101,7 +109,7 @@ class CBlockTreeDB : public CDBWrapper
         EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
     /// Migrate old synchronous index data to new async index databases
-    bool MigrateOldIndexData() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
+    bool MigrateOldIndexData(const fs::path& data_dir, const IndexMigrationOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 };
 
 #endif // BITCOIN_TXDB_H
diff --git a/src/util/thread.cpp b/src/util/thread.cpp
index e8daf429e8dd..b8359bb90be6 100644
--- a/src/util/thread.cpp
+++ b/src/util/thread.cpp
@@ -4,12 +4,22 @@
 
 #include <util/thread.h>
 
+#include <ctpl_stl.h>
 #include <logging.h>
+#include <tinyformat.h>
 #include <util/exception.h>
 #include <util/threadnames.h>
+#include <util/time.h>
 
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
 #include <exception>
 #include <functional>
+#include <future>
+#include <map>
+#include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 
@@ -25,3 +35,41 @@ void util::TraceThread(std::string_view thread_name, std::function<void()> threa
         throw;
     }
 }
+
+void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName)
+{
+    auto cond = std::make_shared<std::condition_variable>();
+    auto mutex = std::make_shared<std::mutex>();
+    std::atomic<int> doneCnt(0);
+    std::map<int, std::future<void>> futures;
+
+    for (int i = 0; i < tp.size(); i++) {
+        futures[i] = tp.push([baseName, i, cond, mutex, &doneCnt](int threadId) {
+            util::ThreadRename(strprintf("%s-%d", baseName, i));
+            std::unique_lock<std::mutex> l(*mutex);
+            doneCnt++;
+            cond->wait(l);
+        });
+    }
+
+    do {
+        // Always sleep to let all threads acquire locks
+        UninterruptibleSleep(std::chrono::milliseconds{10});
+        // `doneCnt` should be at least `futures.size()` if tp size was increased (for whatever reason),
+        // or at least `tp.size()` if tp size was decreased and queue was cleared
+        // (which can happen on `stop()` if we were not fast enough to get all jobs to their threads).
+    } while (uint64_t(doneCnt) < futures.size() && doneCnt < tp.size());
+
+    cond->notify_all();
+
+    // Make sure no one is left behind, just in case
+    for (auto& pair : futures) {
+        auto& f = pair.second;
+        if (f.valid() && f.wait_for(std::chrono::milliseconds(2000)) == std::future_status::timeout) {
+            LogPrintf("%s: %s-%d timed out\n", __func__, baseName, pair.first);
+            // Notify everyone again
+            cond->notify_all();
+            break;
+        }
+    }
+}
diff --git a/src/util/thread.h b/src/util/thread.h
index 8a2de84a7f9d..87c612a3286f 100644
--- a/src/util/thread.h
+++ b/src/util/thread.h
@@ -8,6 +8,10 @@
 #include <functional>
 #include <string>
 
+namespace ctpl {
+class thread_pool;
+} // namespace ctpl
+
 namespace util {
 /**
  * A wrapper for do-something-once thread functions.
@@ -16,4 +20,7 @@ void TraceThread(std::string_view thread_name, std::function<void()> thread_func
 
 } // namespace util
 
+/** Give every thread of the pool the name "<baseName>-<n>". */
+void RenameThreadPool(ctpl::thread_pool& tp, const char* baseName);
+
 #endif // BITCOIN_UTIL_THREAD_H
diff --git a/src/validation.cpp b/src/validation.cpp
index f63a3ad06684..0e44f680132c 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -35,7 +35,6 @@
 #include <logging.h>
 #include <logging/timer.h>
 #include <node/blockstorage.h>
-#include <node/interface_ui.h>
 #include <node/utxo_snapshot.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -127,12 +126,6 @@ GlobalMutex g_best_block_mutex;
 std::condition_variable g_best_block_cv;
 uint256 g_best_block;
 
-// Forward declaration to break dependency over node/transaction.h
-namespace node
-{
-CTransactionRef GetTransaction(const CBlockIndex* const block_index, const CTxMemPool* const mempool, const uint256& hash, uint256& hashBlock, const BlockManager& blockman);
-} // namespace node
-using node::GetTransaction;
 
 namespace {
 
@@ -904,10 +897,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
     if (auto conflictLockOpt = m_isman ? m_isman->ConflictingISLockIfAny(tx) : std::nullopt; conflictLockOpt.has_value()) {
         auto& [_, conflict_txid] = conflictLockOpt.value();
 
-        uint256 hashBlock;
-        if (auto txConflict = GetTransaction(nullptr, &m_pool, conflict_txid, hashBlock, m_active_chainstate.m_blockman); txConflict) {
-            GetMainSignals().NotifyInstantSendDoubleSpendAttempt(ptx, txConflict);
-        }
+        GetMainSignals().NotifyInstantSendDoubleSpendAttempt(ptx, m_pool.get(conflict_txid), conflict_txid);
         LogPrintf("ERROR: AcceptToMemoryPool : Transaction %s conflicts with locked TX %s\n", hash.ToString(), conflict_txid.ToString());
         return state.Invalid(TxValidationResult::TX_CONFLICT_LOCK, "tx-txlock-conflict");
     }
@@ -2387,7 +2377,7 @@ DisconnectResult Chainstate::DisconnectBlock(const CBlock& block, const CBlockIn
 
     if (this == &m_chainman.ActiveChainstate() && mnlist_updates.diff.HasChanges()) {
         GetMainSignals().NotifyMasternodeListChanged(true, mnlist_updates.old_list, mnlist_updates.diff);
-        uiInterface.NotifyMasternodeListChanged(mnlist_updates.new_list, pindex->pprev);
+        m_chainman.GetNotifications().masternodeListChanged(mnlist_updates.new_list, pindex->pprev);
     }
 
     auto finish = Now<SteadyMilliseconds>();
@@ -3116,7 +3106,7 @@ bool Chainstate::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     if (this == &m_chainman.ActiveChainstate() && mnlist_updates.diff.HasChanges()) {
         GetMainSignals().NotifyMasternodeListChanged(false, mnlist_updates.old_list, mnlist_updates.diff);
-        uiInterface.NotifyMasternodeListChanged(mnlist_updates.new_list, pindex);
+        m_chainman.GetNotifications().masternodeListChanged(mnlist_updates.new_list, pindex);
     }
 
     ::g_stats_client->timing("ConnectBlock_ms", Ticks<std::chrono::milliseconds>(time_8 - time_start), 1.0f);
diff --git a/src/validationinterface.cpp b/src/validationinterface.cpp
index 3b7bf4528c75..bbb4328470e9 100644
--- a/src/validationinterface.cpp
+++ b/src/validationinterface.cpp
@@ -307,13 +307,13 @@ void CMainSignals::NotifyGovernanceObject(const std::shared_ptr<const Governance
     ENQUEUE_AND_LOG_EVENT(event, "%s: notify governance object: %s", __func__, id);
 }
 
-void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) {
-    auto event = [currentTx, previousTx, this] {
-        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx); });
+void CMainSignals::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid) {
+    auto event = [currentTx, previousTx, previous_txid, this] {
+        m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx, previous_txid); });
     };
     ENQUEUE_AND_LOG_EVENT(event, "%s: notify instant doublespendattempt currenttxid=%s previoustxid=%s", __func__,
             currentTx->GetHash().ToString(),
-            previousTx->GetHash().ToString());
+            previous_txid.ToString());
 }
 
 void CMainSignals::NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, const std::string& id, bool proactive_relay) {
diff --git a/src/validationinterface.h b/src/validationinterface.h
index 953149c3b263..10a586ffa6ba 100644
--- a/src/validationinterface.h
+++ b/src/validationinterface.h
@@ -179,7 +179,8 @@ class CValidationInterface {
     virtual void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig) {}
     virtual void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote) {}
     virtual void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object) {}
-    virtual void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) {}
+    /** previousTx is the conflicting transaction if the mempool had it when the attempt was detected, nullptr otherwise. */
+    virtual void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid) {}
     virtual void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool proactive_relay) {}
     virtual void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff) {}
     /**
@@ -248,7 +249,7 @@ class CMainSignals {
     void NotifyChainLock(const CBlockIndex* pindex, const std::shared_ptr<const chainlock::ChainLockSig>& clsig, const std::string& id);
     void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote, const std::string& id);
     void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object, const std::string& id);
-    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef &currentTx, const CTransactionRef &previousTx);
+    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid);
     void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig> &sig, const std::string& id, bool proactive_relay);
     void NotifyMasternodeListChanged(bool undo, const CDeterministicMNList& oldMNList, const CDeterministicMNListDiff& diff);
     void ChainStateFlushed(const CBlockLocator &);
diff --git a/src/zmq/zmqnotificationinterface.cpp b/src/zmq/zmqnotificationinterface.cpp
index 8dcfc4986d44..3111abd8b3b4 100644
--- a/src/zmq/zmqnotificationinterface.cpp
+++ b/src/zmq/zmqnotificationinterface.cpp
@@ -40,7 +40,8 @@ std::list<const CZMQAbstractNotifier*> CZMQNotificationInterface::GetActiveNotif
     return result;
 }
 
-std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index)
+std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index,
+                                                                             std::function<CTransactionRef(const uint256&)> get_transaction)
 {
     std::map<std::string, CZMQNotifierFactory> factories;
     factories["pubhashblock"] = CZMQAbstractNotifier::Create<CZMQPublishHashBlockNotifier>;
@@ -92,6 +93,7 @@ std::unique_ptr<CZMQNotificationInterface> CZMQNotificationInterface::Create(std
     {
         std::unique_ptr<CZMQNotificationInterface> notificationInterface(new CZMQNotificationInterface());
         notificationInterface->notifiers = std::move(notifiers);
+        notificationInterface->m_get_transaction = std::move(get_transaction);
 
         if (notificationInterface->Initialize()) {
             return notificationInterface;
@@ -250,10 +252,12 @@ void CZMQNotificationInterface::NotifyGovernanceObject(const std::shared_ptr<con
     });
 }
 
-void CZMQNotificationInterface::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx)
+void CZMQNotificationInterface::NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid)
 {
-    TryForEachAndRemoveFailed(notifiers, [&currentTx, &previousTx](CZMQAbstractNotifier* notifier) {
-        return notifier->NotifyInstantSendDoubleSpendAttempt(currentTx, previousTx);
+    const CTransactionRef conflictTx{previousTx ? previousTx : m_get_transaction(previous_txid)};
+    if (!conflictTx) return;
+    TryForEachAndRemoveFailed(notifiers, [&currentTx, &conflictTx](CZMQAbstractNotifier* notifier) {
+        return notifier->NotifyInstantSendDoubleSpendAttempt(currentTx, conflictTx);
     });
 }
 
diff --git a/src/zmq/zmqnotificationinterface.h b/src/zmq/zmqnotificationinterface.h
index 8858dfc00349..fdae9f6160f6 100644
--- a/src/zmq/zmqnotificationinterface.h
+++ b/src/zmq/zmqnotificationinterface.h
@@ -24,7 +24,8 @@ class CZMQNotificationInterface final : public CValidationInterface
 
     std::list<const CZMQAbstractNotifier*> GetActiveNotifiers() const;
 
-    static std::unique_ptr<CZMQNotificationInterface> Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index);
+    static std::unique_ptr<CZMQNotificationInterface> Create(std::function<bool(CBlock&, const CBlockIndex&)> get_block_by_index,
+                                                             std::function<CTransactionRef(const uint256&)> get_transaction);
 
 protected:
     bool Initialize();
@@ -40,7 +41,7 @@ class CZMQNotificationInterface final : public CValidationInterface
     void NotifyTransactionLock(const CTransactionRef &tx, const std::shared_ptr<const instantsend::InstantSendLock>& islock) override;
     void NotifyGovernanceVote(const std::shared_ptr<CDeterministicMNList>& tip_mn_list, const std::shared_ptr<const CGovernanceVote>& vote) override;
     void NotifyGovernanceObject(const std::shared_ptr<const Governance::Object>& object) override;
-    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx) override;
+    void NotifyInstantSendDoubleSpendAttempt(const CTransactionRef& currentTx, const CTransactionRef& previousTx, const uint256& previous_txid) override;
     void NotifyRecoveredSig(const std::shared_ptr<const llmq::CRecoveredSig>& sig, bool /*proactive_relay*/) override;
 
 private:
@@ -48,6 +49,7 @@ class CZMQNotificationInterface final : public CValidationInterface
 
     void* pcontext{nullptr};
     std::list<std::unique_ptr<CZMQAbstractNotifier>> notifiers;
+    std::function<CTransactionRef(const uint256&)> m_get_transaction;
 };
 
 extern std::unique_ptr<CZMQNotificationInterface> g_zmq_notification_interface;