diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index be5b6110fa2f7..6537e4fd2a50d 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -855,7 +855,8 @@ class CRegTestParams : public CChainParams {
         assert(genesis.hashMerkleRoot == uint256S("0xe0028eb9648db56b1ac77cf090b99048a8007e2bb64b68f092c03c7f56a662c7"));
 
         vFixedSeeds.clear(); //!< Regtest mode doesn't have any fixed seeds.
-        vSeeds.clear();      //!< Regtest mode doesn't have any DNS seeds.
+        vSeeds.clear();
+        vSeeds.emplace_back("dummySeed.invalid.");
 
         fDefaultConsistencyChecks = true;
         fRequireStandard = true;
diff --git a/src/init.cpp b/src/init.cpp
index c831ed4986a81..b16bc62b6d7d3 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -1223,6 +1223,11 @@ bool AppInitParameterInteraction(const ArgsManager& args)
 
     fAllowPrivateNet = args.GetBoolArg("-allowprivatenet", DEFAULT_ALLOWPRIVATENET);
 
+    // If -forcednsseed is set to true, ensure -dnsseed has not been set to false
+    if (args.GetBoolArg("-forcednsseed", DEFAULT_FORCEDNSSEED) && !args.GetBoolArg("-dnsseed", DEFAULT_DNSSEED)){
+        return InitError(_("Cannot set -forcednsseed to true when setting -dnsseed to false."));
+    }
+
     // -bind and -whitebind can't be set when not listening
     size_t nUserBind = args.GetArgs("-bind").size() + args.GetArgs("-whitebind").size();
     if (nUserBind != 0 && !args.GetBoolArg("-listen", DEFAULT_LISTEN)) {
diff --git a/src/net.cpp b/src/net.cpp
index 69c279eace73d..7dc92be426377 100644
--- a/src/net.cpp
+++ b/src/net.cpp
@@ -2680,7 +2680,7 @@ void CConnman::ThreadDNSAddressSeed()
                     {
                         READ_LOCK(m_nodes_mutex);
                         for (const CNode* pnode : m_nodes) {
-                            if (pnode->fSuccessfullyConnected && !pnode->IsFullOutboundConn() && !pnode->m_masternode_probe_connection) ++nRelevant;
+                            if (pnode->fSuccessfullyConnected && pnode->IsFullOutboundConn() && !pnode->m_masternode_probe_connection) ++nRelevant;
                         }
                     }
                     if (nRelevant >= 2) {
diff --git a/src/net.h b/src/net.h
index f49f93c45449c..1a0a9f3f4ede6 100644
--- a/src/net.h
+++ b/src/net.h
@@ -112,9 +112,9 @@ static const int64_t DEFAULT_PEER_CONNECT_TIMEOUT = 60;
 /** Number of file descriptors required for message capture **/
 static const int NUM_FDS_MESSAGE_CAPTURE = 1;
 
-static const bool DEFAULT_FORCEDNSSEED = false;
-static const bool DEFAULT_DNSSEED = true;
-static const bool DEFAULT_FIXEDSEEDS = true;
+static constexpr bool DEFAULT_FORCEDNSSEED{false};
+static constexpr bool DEFAULT_DNSSEED{true};
+static constexpr bool DEFAULT_FIXEDSEEDS{true};
 static const size_t DEFAULT_MAXRECEIVEBUFFER = 5 * 1000;
 static const size_t DEFAULT_MAXSENDBUFFER    = 1 * 1000;
 
@@ -1386,29 +1386,6 @@ friend class CNode;
         ForEachNode(FullyConnectedOnly, fn);
     }
 
-    template<typename Callable, typename CallableAfter>
-    void ForEachNodeThen(Callable&& pre, CallableAfter&& post) EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex)
-    {
-        ForEachNodeThen(FullyConnectedOnly, pre, post);
-    }
-
-    template<typename Condition, typename Callable, typename CallableAfter>
-    void ForEachNodeThen(const Condition& cond, Callable&& pre, CallableAfter&& post) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex)
-    {
-        READ_LOCK(m_nodes_mutex);
-        for (auto&& node : m_nodes) {
-            if (cond(node))
-                pre(node);
-        }
-        post();
-    };
-
-    template<typename Callable, typename CallableAfter>
-    void ForEachNodeThen(Callable&& pre, CallableAfter&& post) const EXCLUSIVE_LOCKS_REQUIRED(!m_nodes_mutex)
-    {
-        ForEachNodeThen(FullyConnectedOnly, pre, post);
-    }
-
     // Addrman functions
     /**
      * Return all or many randomly selected addresses, optionally by network.
diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
index a384301cdfa92..eca6536c19661 100644
--- a/src/qt/rpcconsole.cpp
+++ b/src/qt/rpcconsole.cpp
@@ -733,7 +733,7 @@ void RPCConsole::setClientModel(ClientModel *model, int bestblock_height, int64_
 
         // create peer table context menu
         peersTableContextMenu = new QMenu(this);
-        //: Context menu action to copy the address of a peer
+        //: Context menu action to copy the address of a peer.
         peersTableContextMenu->addAction(tr("&Copy address"), [this] {
             GUIUtil::copyEntryData(ui->peerWidget, PeerTableModel::Address, Qt::DisplayRole);
         });
@@ -767,7 +767,7 @@ void RPCConsole::setClientModel(ClientModel *model, int bestblock_height, int64_
         banTableContextMenu = new QMenu(this);
         /*: Context menu action to copy the IP/Netmask of a banned peer.
             IP/Netmask is the combination of a peer's IP address and its Netmask.
-            For IP address see: https://en.wikipedia.org/wiki/IP_address */
+            For IP address, see: https://en.wikipedia.org/wiki/IP_address. */
         banTableContextMenu->addAction(tr("&Copy IP/Netmask"), [this] {
             GUIUtil::copyEntryData(ui->banlistWidget, BanTableModel::Address, Qt::DisplayRole);
         });
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index 146ed5cefe8cf..066984c219dbd 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -227,7 +227,7 @@ void SendCoinsDialog::setModel(WalletModel *_model)
         updateSmartFeeLabel();
 
         if (model->wallet().hasExternalSigner()) {
-            //: "device" usually means a hardware wallet
+            //: "device" usually means a hardware wallet.
             ui->sendButton->setText(tr("Sign on device"));
             if (gArgs.GetArg("-signer", "") != "") {
                 ui->sendButton->setEnabled(true);
diff --git a/src/rpc/external_signer.cpp b/src/rpc/external_signer.cpp
index 91a21f4e4d5ba..ece157c8b41f2 100644
--- a/src/rpc/external_signer.cpp
+++ b/src/rpc/external_signer.cpp
@@ -23,8 +23,11 @@ static RPCHelpMan enumeratesigners()
             {
                 {RPCResult::Type::ARR, "signers", /*optional=*/false, "",
                 {
-                    {RPCResult::Type::STR_HEX, "masterkeyfingerprint", "Master key fingerprint"},
-                    {RPCResult::Type::STR, "name", "Device name"},
+                    {RPCResult::Type::OBJ, "", "",
+                    {
+                        {RPCResult::Type::STR_HEX, "fingerprint", "Master key fingerprint"},
+                        {RPCResult::Type::STR, "name", "Device name"},
+                    }},
                 },
                 }
             }
diff --git a/src/test/fuzz/addrman.cpp b/src/test/fuzz/addrman.cpp
index ba953d33c5e36..1a79febb8a705 100644
--- a/src/test/fuzz/addrman.cpp
+++ b/src/test/fuzz/addrman.cpp
@@ -259,15 +259,6 @@ FUZZ_TARGET(addrman, .init = initialize_addrman)
             [&] {
                 (void)addr_man.SelectTriedCollision();
             },
-            [&] {
-                (void)addr_man.Select(fuzzed_data_provider.ConsumeBool());
-            },
-            [&] {
-                (void)addr_man.GetAddr(
-                    /*max_addresses=*/fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096),
-                    /*max_pct=*/fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096),
-                    /*network=*/std::nullopt);
-            },
             [&] {
                 std::vector<CAddress> addresses;
                 LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) {
@@ -288,9 +279,15 @@ FUZZ_TARGET(addrman, .init = initialize_addrman)
                 addr_man.SetServices(ConsumeService(fuzzed_data_provider), ConsumeWeakEnum(fuzzed_data_provider, ALL_SERVICE_FLAGS));
             });
     }
-    (void)addr_man.Size();
+    const AddrMan& const_addr_man{addr_man};
+    (void)const_addr_man.GetAddr(
+        /* max_addresses */ fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096),
+        /* max_pct */ fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 4096),
+        /* network */ std::nullopt);
+    (void)const_addr_man.Select(fuzzed_data_provider.ConsumeBool());
+    (void)const_addr_man.Size();
     CDataStream data_stream(SER_NETWORK, PROTOCOL_VERSION);
-    data_stream << addr_man;
+    data_stream << const_addr_man;
 }
 
 // Check that serialize followed by unserialize produces the same addrman.
@@ -309,4 +306,4 @@ FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
     data_stream << addr_man1;
     data_stream >> addr_man2;
     assert(addr_man1 == addr_man2);
-}
\ No newline at end of file
+}
diff --git a/src/test/fuzz/connman.cpp b/src/test/fuzz/connman.cpp
index 2a923e482691d..54c0edbbd6ea8 100644
--- a/src/test/fuzz/connman.cpp
+++ b/src/test/fuzz/connman.cpp
@@ -87,9 +87,6 @@ FUZZ_TARGET(connman, .init = initialize_connman)
             [&] {
                 connman.ForEachNode([](auto) {});
             },
-            [&] {
-                connman.ForEachNodeThen([](auto) {}, []() {});
-            },
             [&] {
                 (void)connman.ForNode(fuzzed_data_provider.ConsumeIntegral<NodeId>(), [&](auto) { return fuzzed_data_provider.ConsumeBool(); });
             },
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
index 608445e297565..eff53706f6cb8 100644
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -17,7 +17,6 @@
 #include <pow.h>
 #include <protocol.h>
 #include <pubkey.h>
-#include <rpc/util.h>
 #include <script/sign.h>
 #include <script/standard.h>
 #include <serialize.h>
@@ -150,14 +149,6 @@ FUZZ_TARGET(integer, .init = initialize_integer)
 
     const PKHash key_id{u160};
     const ScriptHash script_id{u160};
-    // CTxDestination = CNoDestination ∪ PKHash ∪ ScriptHash
-    const std::vector<CTxDestination> destinations{key_id, script_id};
-    for (const CTxDestination& destination : destinations) {
-        (void)DescribeAddress(destination);
-        (void)EncodeDestination(destination);
-        (void)GetScriptForDestination(destination);
-        (void)IsValidDestination(destination);
-    }
 
     {
         CDataStream stream(SER_NETWORK, INIT_PROTO_VERSION);
diff --git a/src/test/fuzz/key_io.cpp b/src/test/fuzz/key_io.cpp
index 9fbea2b45f6ce..aa9338259a259 100644
--- a/src/test/fuzz/key_io.cpp
+++ b/src/test/fuzz/key_io.cpp
@@ -4,8 +4,6 @@
 
 #include <chainparams.h>
 #include <key_io.h>
-#include <rpc/util.h>
-#include <script/standard.h>
 #include <test/fuzz/fuzz.h>
 
 #include <cassert>
@@ -37,12 +35,4 @@ FUZZ_TARGET(key_io, .init = initialize_key_io)
     if (ext_pub_key.pubkey.size() == CPubKey::COMPRESSED_SIZE) {
         assert(ext_pub_key == DecodeExtPubKey(EncodeExtPubKey(ext_pub_key)));
     }
-
-    const CTxDestination tx_destination = DecodeDestination(random_string);
-    (void)DescribeAddress(tx_destination);
-    (void)GetKeyForDestination(/*store=*/{}, tx_destination);
-    (void)GetScriptForDestination(tx_destination);
-    (void)IsValidDestination(tx_destination);
-
-    (void)IsValidDestinationString(random_string);
 }
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index 6e1d37e5c573d..de51ff1bba448 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -7,8 +7,10 @@
 #include <core_io.h>
 #include <core_memusage.h>
 #include <key.h>
+#include <key_io.h>
 #include <policy/policy.h>
 #include <pubkey.h>
+#include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/interpreter.h>
 #include <script/script.h>
@@ -126,9 +128,26 @@ FUZZ_TARGET(script, .init = initialize_script)
     }
 
     {
-        const CTxDestination tx_destination_1 = ConsumeTxDestination(fuzzed_data_provider);
-        const CTxDestination tx_destination_2 = ConsumeTxDestination(fuzzed_data_provider);
-        (void)(tx_destination_1 == tx_destination_2);
+        const CTxDestination tx_destination_1{
+            fuzzed_data_provider.ConsumeBool() ?
+                DecodeDestination(fuzzed_data_provider.ConsumeRandomLengthString()) :
+                ConsumeTxDestination(fuzzed_data_provider)};
+        const CTxDestination tx_destination_2{ConsumeTxDestination(fuzzed_data_provider)};
+        const std::string encoded_dest{EncodeDestination(tx_destination_1)};
+        const UniValue json_dest{DescribeAddress(tx_destination_1)};
+        Assert(tx_destination_1 == DecodeDestination(encoded_dest));
+        (void)GetKeyForDestination(/* store */ {}, tx_destination_1);
+        const CScript dest{GetScriptForDestination(tx_destination_1)};
+        const bool valid{IsValidDestination(tx_destination_1)};
+        Assert(dest.empty() != valid);
+
+        Assert(valid == IsValidDestinationString(encoded_dest));
+
         (void)(tx_destination_1 < tx_destination_2);
+        if (tx_destination_1 == tx_destination_2) {
+            Assert(encoded_dest == EncodeDestination(tx_destination_2));
+            Assert(json_dest.write() == DescribeAddress(tx_destination_2).write());
+            Assert(dest == GetScriptForDestination(tx_destination_2));
+        }
     }
 }
diff --git a/src/test/fuzz/util.cpp b/src/test/fuzz/util.cpp
index d772d0954f94e..c2d9d33175b7e 100644
--- a/src/test/fuzz/util.cpp
+++ b/src/test/fuzz/util.cpp
@@ -5,6 +5,7 @@
 #include <net_processing.h>
 #include <netaddress.h>
 #include <netmessagemaker.h>
+#include <pubkey.h>
 #include <test/fuzz/util.h>
 #include <test/util/script.h>
 #include <util/overflow.h>
@@ -435,6 +436,24 @@ uint32_t ConsumeSequence(FuzzedDataProvider& fuzzed_data_provider) noexcept
                fuzzed_data_provider.ConsumeIntegral<uint32_t>();
 }
 
+CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept
+{
+    CTxDestination tx_destination;
+    const size_t call_size{CallOneOf(
+        fuzzed_data_provider,
+        [&] {
+            tx_destination = CNoDestination{};
+        },
+        [&] {
+            tx_destination = PKHash{ConsumeUInt160(fuzzed_data_provider)};
+        },
+        [&] {
+            tx_destination = ScriptHash{ConsumeUInt160(fuzzed_data_provider)};
+        })};
+    Assert(call_size == std::variant_size_v<CTxDestination>);
+    return tx_destination;
+}
+
 CKey ConsumePrivateKey(FuzzedDataProvider& fuzzed_data_provider, std::optional<bool> compressed) noexcept
 {
     auto key_data = fuzzed_data_provider.ConsumeBytes<uint8_t>(32);
diff --git a/src/test/fuzz/util.h b/src/test/fuzz/util.h
index ea008b8f50ffb..81cce371f7c88 100644
--- a/src/test/fuzz/util.h
+++ b/src/test/fuzz/util.h
@@ -101,7 +101,7 @@ class FuzzedSock : public Sock
 }
 
 template <typename... Callables>
-void CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
+size_t CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
 {
     constexpr size_t call_size{sizeof...(callables)};
     static_assert(call_size >= 1);
@@ -109,6 +109,7 @@ void CallOneOf(FuzzedDataProvider& fuzzed_data_provider, Callables... callables)
 
     size_t i{0};
     ((i++ == call_index ? callables() : void()), ...);
+    return call_size;
 }
 
 template <typename Collection>
@@ -233,22 +234,7 @@ template <typename WeakEnumType, size_t size>
 
 [[nodiscard]] CTxMemPoolEntry ConsumeTxMemPoolEntry(FuzzedDataProvider& fuzzed_data_provider, const CTransaction& tx) noexcept;
 
-[[nodiscard]] inline CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept
-{
-    CTxDestination tx_destination;
-    CallOneOf(
-        fuzzed_data_provider,
-        [&] {
-            tx_destination = CNoDestination{};
-        },
-        [&] {
-            tx_destination = PKHash{ConsumeUInt160(fuzzed_data_provider)};
-        },
-        [&] {
-            tx_destination = ScriptHash{ConsumeUInt160(fuzzed_data_provider)};
-        });
-    return tx_destination;
-}
+[[nodiscard]] CTxDestination ConsumeTxDestination(FuzzedDataProvider& fuzzed_data_provider) noexcept;
 
 [[nodiscard]] CKey ConsumePrivateKey(FuzzedDataProvider& fuzzed_data_provider, std::optional<bool> compressed = std::nullopt) noexcept;
 
diff --git a/test/functional/feature_config_args.py b/test/functional/feature_config_args.py
index 88e900a011e89..2e8e58a6027f3 100755
--- a/test/functional/feature_config_args.py
+++ b/test/functional/feature_config_args.py
@@ -183,15 +183,19 @@ def test_seed_peers(self):
         self.stop_node(0)
 
         # No peers.dat exists and -dnsseed=1
-        # We expect the node will use DNS Seeds, but Regtest mode has 0 DNS seeds
-        # So after 60 seconds, the node should fallback to fixed seeds (this is a slow test)
+        # We expect the node will use DNS Seeds, but Regtest mode does not have
+        # any valid DNS seeds. So after 60 seconds, the node should fallback to
+        # fixed seeds
         assert not os.path.exists(os.path.join(default_data_dir, "peers.dat"))
         start = int(time.time())
-        with self.nodes[0].assert_debug_log(expected_msgs=[
-                "Loaded 0 addresses from peers.dat",
-                "0 addresses found from DNS seeds",
-                "opencon thread start",  # Ensure ThreadOpenConnections::start time is properly set
-        ]):
+        with self.nodes[0].assert_debug_log(
+                expected_msgs=[
+                    "Loaded 0 addresses from peers.dat",
+                    "0 addresses found from DNS seeds",
+                    "opencon thread start",  # Ensure ThreadOpenConnections::start time is properly set
+                ],
+                timeout=10,
+        ):
             self.start_node(0, extra_args=['-dnsseed=1', '-fixedseeds=1', f'-mocktime={start}'])
         with self.nodes[0].assert_debug_log(expected_msgs=[
                 "Adding fixed seeds as 60 seconds have passed and addrman is empty",
@@ -226,11 +230,14 @@ def test_seed_peers(self):
         # We expect the node will allow 60 seconds prior to using fixed seeds
         assert not os.path.exists(os.path.join(default_data_dir, "peers.dat"))
         start = int(time.time())
-        with self.nodes[0].assert_debug_log(expected_msgs=[
-                "Loaded 0 addresses from peers.dat",
-                "DNS seeding disabled",
-                "opencon thread start",  # Ensure ThreadOpenConnections::start time is properly set
-        ]):
+        with self.nodes[0].assert_debug_log(
+                expected_msgs=[
+                    "Loaded 0 addresses from peers.dat",
+                    "DNS seeding disabled",
+                    "opencon thread start",  # Ensure ThreadOpenConnections::start time is properly set
+                ],
+                timeout=10,
+        ):
             self.start_node(0, extra_args=['-dnsseed=0', '-fixedseeds=1', '-addnode=fakenodeaddr', f'-mocktime={start}'])
         with self.nodes[0].assert_debug_log(expected_msgs=[
                 "Adding fixed seeds as 60 seconds have passed and addrman is empty",
diff --git a/test/functional/mempool_package_limits.py b/test/functional/mempool_package_limits.py
index 68a26aad953ec..f4ee1e49eac51 100755
--- a/test/functional/mempool_package_limits.py
+++ b/test/functional/mempool_package_limits.py
@@ -24,6 +24,7 @@
     bulk_transaction,
     create_child_with_parents,
     make_chain,
+    DEFAULT_FEE,
 )
 
 class MempoolPackageLimitsTest(BitcoinTestFramework):
@@ -48,6 +49,7 @@ def run_test(self):
 
         self.test_chain_limits()
         self.test_desc_count_limits()
+        self.test_desc_count_limits_2()
         self.test_anc_count_limits()
         self.test_anc_count_limits_2()
         self.test_anc_count_limits_bushy()
@@ -174,6 +176,73 @@ def test_desc_count_limits(self):
         self.generate(node, 1)
         assert all([res["allowed"] for res in node.testmempoolaccept(rawtxs=package_hex)])
 
+    def test_desc_count_limits_2(self):
+        """Create a Package with 24 transaction in mempool and 2 transaction in package:
+                      M1
+                     ^  ^
+                   M2    ^
+                   .      ^
+                  .        ^
+                 .          ^
+                M24          ^
+                              ^
+                              P1
+                              ^
+                              P2
+        P1 has M1 as a mempool ancestor, P2 has no in-mempool ancestors, but when
+        combined P2 has M1 as an ancestor and M1 exceeds descendant_limits(23 in-mempool
+        descendants + 2 in-package descendants, a total of 26 including itself).
+        """
+
+        node = self.nodes[0]
+        package_hex = []
+        # M1
+        first_coin_a = self.coins.pop()
+        parent_value = (first_coin_a["amount"] - DEFAULT_FEE) / 2 # Deduct reasonable fee and make 2 outputs
+        inputs = [{"txid": first_coin_a["txid"], "vout": 0}]
+        outputs = [{self.address : parent_value}, {ADDRESS_BCRT1_P2SH_OP_TRUE : parent_value}]
+        rawtx = node.createrawtransaction(inputs, outputs)
+
+        parent_signed = node.signrawtransactionwithkey(hexstring=rawtx, privkeys=self.privkeys)
+        assert parent_signed["complete"]
+        parent_tx = tx_from_hex(parent_signed["hex"])
+        parent_txid = parent_tx.rehash()
+        node.sendrawtransaction(parent_signed["hex"])
+
+        # Chain M2...M24
+        spk = parent_tx.vout[0].scriptPubKey.hex()
+        value = parent_value
+        txid = parent_txid
+        for i in range(23): # M2...M24
+            (tx, txhex, value, spk) = make_chain(node, self.address, self.privkeys, txid, value, 0, spk)
+            txid = tx.rehash()
+            node.sendrawtransaction(txhex)
+
+        # P1
+        value_p1 = (parent_value - DEFAULT_FEE)
+        rawtx_p1 = node.createrawtransaction([{"txid": parent_txid, "vout": 1}], [{self.address : value_p1}])
+        tx_child_p1 = tx_from_hex(rawtx_p1)
+        tx_child_p1.vin[0].scriptSig = CScript([CScript([OP_TRUE])])
+        tx_child_p1_hex = tx_child_p1.serialize().hex()
+        txid_child_p1 = tx_child_p1.rehash()
+        package_hex.append(tx_child_p1_hex)
+        tx_child_p1_spk = tx_child_p1.vout[0].scriptPubKey.hex()
+
+        # P2
+        (_, tx_child_p2_hex, _, _) = make_chain(node, self.address, self.privkeys, txid_child_p1, value_p1, 0, tx_child_p1_spk)
+        package_hex.append(tx_child_p2_hex)
+
+        assert_equal(24, node.getmempoolinfo()["size"])
+        assert_equal(2, len(package_hex))
+        testres = node.testmempoolaccept(rawtxs=package_hex)
+        assert_equal(len(testres), len(package_hex))
+        for txres in testres:
+            assert_equal(txres["package-error"], "package-mempool-limits")
+
+        # Clear mempool and check that the package passes now
+        self.generate(node, 1)
+        assert all([res["allowed"] for res in node.testmempoolaccept(rawtxs=package_hex)])
+
     def test_anc_count_limits(self):
         """Create a 'V' shaped chain with 24 transactions in the mempool and 3 in the package:
         M1a                    M1b
diff --git a/test/functional/p2p_addr_relay.py b/test/functional/p2p_addr_relay.py
index 978bf5e655ecb..083f3ef4f1b2f 100755
--- a/test/functional/p2p_addr_relay.py
+++ b/test/functional/p2p_addr_relay.py
@@ -10,20 +10,20 @@
 
 from test_framework.messages import (
     CAddress,
-    NODE_NETWORK,
     msg_addr,
     msg_getaddr,
-    msg_verack
+    msg_verack,
 )
 from test_framework.p2p import (
     P2PInterface,
     p2p_lock,
+    P2P_SERVICES,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
-    assert_greater_than_or_equal
+    assert_greater_than_or_equal,
 )
 
 ONE_MINUTE  = 60
@@ -51,7 +51,7 @@ def on_addr(self, message):
             if(self.test_addr_contents):
                 # relay_tests checks the content of the addr messages match
                 # expectations based on the message creation in setup_addr_msg
-                assert_equal(addr.nServices, 1)
+                assert_equal(addr.nServices, 2049)
                 if not 8333 <= addr.port < 8343:
                     raise AssertionError("Invalid addr.port of {} (8333-8342 expected)".format(addr.port))
                 assert addr.ip.startswith('123.123.')
@@ -109,7 +109,7 @@ def setup_addr_msg(self, num, sequential_ips=True):
         for i in range(num):
             addr = CAddress()
             addr.time = self.mocktime + random.randrange(-100, 100)
-            addr.nServices = NODE_NETWORK
+            addr.nServices = P2P_SERVICES
             if sequential_ips:
                 assert self.counter < 256 ** 2  # Don't allow the returned ip addresses to wrap.
                 addr.ip = f"123.123.{self.counter // 256}.{self.counter % 256}"
diff --git a/test/functional/p2p_addrfetch.py b/test/functional/p2p_addrfetch.py
index f155b907fa267..25efd50040c8e 100755
--- a/test/functional/p2p_addrfetch.py
+++ b/test/functional/p2p_addrfetch.py
@@ -8,14 +8,21 @@
 
 import time
 
-from test_framework.messages import msg_addr, CAddress, NODE_NETWORK
-from test_framework.p2p import P2PInterface, p2p_lock
+from test_framework.messages import (
+    CAddress,
+    msg_addr,
+)
+from test_framework.p2p import (
+    P2PInterface,
+    p2p_lock,
+    P2P_SERVICES,
+)
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
 ADDR = CAddress()
 ADDR.time = int(time.time())
-ADDR.nServices = NODE_NETWORK
+ADDR.nServices = P2P_SERVICES
 ADDR.ip = "192.0.0.8"
 ADDR.port = 18444
 
diff --git a/test/functional/p2p_addrv2_relay.py b/test/functional/p2p_addrv2_relay.py
index 86d3e4676e6fd..46d49b531f490 100755
--- a/test/functional/p2p_addrv2_relay.py
+++ b/test/functional/p2p_addrv2_relay.py
@@ -11,9 +11,11 @@
 from test_framework.messages import (
     CAddress,
     msg_addrv2,
-    NODE_NETWORK,
 )
-from test_framework.p2p import P2PInterface
+from test_framework.p2p import (
+    P2PInterface,
+    P2P_SERVICES,
+)
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
@@ -42,7 +44,7 @@ def calc_addrv2_msg_size(addrs):
     size = 1  # vector length byte
     for addr in addrs:
         size += 4  # time
-        size += 1  # services, COMPACTSIZE(P2P_SERVICES)
+        size += 3  # services, COMPACTSIZE(P2P_SERVICES)
         size += 1  # network id
         size += 1  # address length byte
         size += addr.ADDRV2_ADDRESS_LENGTH[addr.net]  # address
@@ -60,7 +62,7 @@ def run_test(self):
             addr = CAddress()
             addr.time = int(self.mocktime) + i
             addr.port = 8333 + i
-            addr.nServices = NODE_NETWORK
+            addr.nServices = P2P_SERVICES
             # Add one I2P and one onion V3 address at an arbitrary position.
             if i == 5:
                 addr.net = addr.NET_I2P
diff --git a/test/functional/p2p_dns_seeds.py b/test/functional/p2p_dns_seeds.py
new file mode 100755
index 0000000000000..e58ad8e0fc811
--- /dev/null
+++ b/test/functional/p2p_dns_seeds.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# Copyright (c) 2021 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test ThreadDNSAddressSeed logic for querying DNS seeds."""
+
+import itertools
+
+from test_framework.p2p import P2PInterface
+from test_framework.test_framework import BitcoinTestFramework
+
+
+class P2PDNSSeeds(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+        self.extra_args = [["-dnsseed=1"]]
+
+    def run_test(self):
+        self.init_arg_tests()
+        self.existing_outbound_connections_test()
+        self.existing_block_relay_connections_test()
+        self.force_dns_test()
+        self.wait_time_tests()
+
+    def init_arg_tests(self):
+        fakeaddr = "fakenodeaddr.fakedomain.invalid."
+
+        self.log.info("Check that setting -connect disables -dnsseed by default")
+        self.nodes[0].stop_node()
+        with self.nodes[0].assert_debug_log(expected_msgs=["DNS seeding disabled"]):
+            self.start_node(0, [f"-connect={fakeaddr}"])
+
+        self.log.info("Check that running -connect and -dnsseed means DNS logic runs.")
+        with self.nodes[0].assert_debug_log(expected_msgs=["Loading addresses from DNS seed"], timeout=12):
+            self.restart_node(0, [f"-connect={fakeaddr}", "-dnsseed=1"])
+
+        self.log.info("Check that running -forcednsseed and -dnsseed=0 throws an error.")
+        self.nodes[0].stop_node()
+        self.nodes[0].assert_start_raises_init_error(
+            expected_msg="Error: Cannot set -forcednsseed to true when setting -dnsseed to false.",
+            extra_args=["-forcednsseed=1", "-dnsseed=0"],
+        )
+
+        self.log.info("Check that running -forcednsseed and -connect throws an error.")
+        # -connect soft sets -dnsseed to false, so throws the same error
+        self.nodes[0].stop_node()
+        self.nodes[0].assert_start_raises_init_error(
+            expected_msg="Error: Cannot set -forcednsseed to true when setting -dnsseed to false.",
+            extra_args=["-forcednsseed=1", f"-connect={fakeaddr}"],
+        )
+
+        # Restore default bitcoind settings
+        self.restart_node(0)
+
+    def existing_outbound_connections_test(self):
+        # Make sure addrman is populated to enter the conditional where we
+        # delay and potentially skip DNS seeding.
+        self.nodes[0].addpeeraddress("192.0.0.8", 8333)
+
+        self.log.info("Check that we *do not* query DNS seeds if we have 2 outbound connections")
+
+        self.restart_node(0)
+        with self.nodes[0].assert_debug_log(expected_msgs=["P2P peers available. Skipped DNS seeding."], timeout=12):
+            for i in range(2):
+                self.nodes[0].add_outbound_p2p_connection(P2PInterface(), p2p_idx=i, connection_type="outbound-full-relay")
+
+    def existing_block_relay_connections_test(self):
+        # Make sure addrman is populated to enter the conditional where we
+        # delay and potentially skip DNS seeding. No-op when run after
+        # existing_outbound_connections_test.
+        self.nodes[0].addpeeraddress("192.0.0.8", 8333)
+
+        self.log.info("Check that we *do* query DNS seeds if we only have 2 block-relay-only connections")
+
+        self.restart_node(0)
+        with self.nodes[0].assert_debug_log(expected_msgs=["Loading addresses from DNS seed"], timeout=12):
+            # This mimics the "anchors" logic where nodes are likely to
+            # reconnect to block-relay-only connections on startup.
+            # Since we do not participate in addr relay with these connections,
+            # we still want to query the DNS seeds.
+            for i in range(2):
+                self.nodes[0].add_outbound_p2p_connection(P2PInterface(), p2p_idx=i, connection_type="block-relay-only")
+
+    def force_dns_test(self):
+        self.log.info("Check that we query DNS seeds if -forcednsseed param is set")
+
+        with self.nodes[0].assert_debug_log(expected_msgs=["Loading addresses from DNS seed"], timeout=12):
+            # -dnsseed defaults to 1 in bitcoind, but 0 in the test framework,
+            # so pass it explicitly here
+            self.restart_node(0, ["-forcednsseed", "-dnsseed=1"])
+
+        # Restore default for subsequent tests
+        self.restart_node(0)
+
+    def wait_time_tests(self):
+        self.log.info("Check the delay before querying DNS seeds")
+
+        # Populate addrman with < 1000 addresses
+        for i in range(5):
+            a = f"192.0.0.{i}"
+            self.nodes[0].addpeeraddress(a, 8333)
+
+        # The delay should be 11 seconds
+        with self.nodes[0].assert_debug_log(expected_msgs=["Waiting 11 seconds before querying DNS seeds.\n"]):
+            self.restart_node(0)
+
+        # Populate addrman with > 1000 addresses
+        for i in itertools.count():
+            first_octet = i % 2 + 1
+            second_octet = i % 256
+            third_octet = i % 100
+            a = f"{first_octet}.{second_octet}.{third_octet}.1"
+            self.nodes[0].addpeeraddress(a, 8333)
+            if (i > 1000 and i % 100 == 0):
+                # The addrman size is non-deterministic because new addresses
+                # are sorted into buckets, potentially displacing existing
+                # addresses. Periodically check if we have met the desired
+                # threshold.
+                if len(self.nodes[0].getnodeaddresses(0)) > 1000:
+                    break
+
+        # The delay should be 5 mins
+        with self.nodes[0].assert_debug_log(expected_msgs=["Waiting 300 seconds before querying DNS seeds.\n"]):
+            self.restart_node(0)
+
+
+if __name__ == '__main__':
+    P2PDNSSeeds().main()
diff --git a/test/functional/rpc_net.py b/test/functional/rpc_net.py
index b3775ca89d505..1e507be864b62 100755
--- a/test/functional/rpc_net.py
+++ b/test/functional/rpc_net.py
@@ -7,11 +7,12 @@
 Tests correspond to code in rpc/net.cpp.
 """
 
-from test_framework.p2p import P2PInterface
 import test_framework.messages
 from test_framework.messages import (
     MAX_PROTOCOL_MESSAGE_LENGTH,
-    NODE_NETWORK,
+)
+from test_framework.p2p import (
+    P2PInterface,
 )
 
 from itertools import product
@@ -270,7 +271,6 @@ def test_service_flags(self):
     def test_getnodeaddresses(self):
         self.log.info("Test getnodeaddresses")
         self.nodes[0].add_p2p_connection(P2PInterface())
-        services = NODE_NETWORK
 
         # Add an IPv6 address to the address manager.
         ipv6_addr = "1233:3432:2434:2343:3234:2345:6546:4534"
@@ -298,7 +298,7 @@ def test_getnodeaddresses(self):
         assert_greater_than(10000, len(node_addresses))
         for a in node_addresses:
             assert_equal(a["time"], self.mocktime)
-            assert_equal(a["services"], services)
+            assert_equal(a["services"], 1)
             assert a["address"] in imported_addrs
             assert_equal(a["port"], 8333)
             assert_equal(a["network"], "ipv4")
@@ -309,7 +309,7 @@ def test_getnodeaddresses(self):
         assert_equal(res[0]["address"], ipv6_addr)
         assert_equal(res[0]["network"], "ipv6")
         assert_equal(res[0]["port"], 8333)
-        assert_equal(res[0]["services"], services)
+        assert_equal(res[0]["services"], 1)
 
         # Test for the absence of onion, I2P and CJDNS addresses.
         for network in ["onion", "i2p", "cjdns"]:
diff --git a/test/functional/rpc_signer.py b/test/functional/rpc_signer.py
index 2d8ae04266528..f1ea22557941d 100755
--- a/test/functional/rpc_signer.py
+++ b/test/functional/rpc_signer.py
@@ -53,8 +53,12 @@ def run_test(self):
         )
 
         # Handle script missing:
-        assert_raises_rpc_error(-1, 'execve failed: No such file or directory',
-            self.nodes[3].enumeratesigners
+        assert_raises_rpc_error(
+            -1,
+            "CreateProcess failed: The system cannot find the file specified."
+            if platform.system() == "Windows"
+            else "execve failed: No such file or directory",
+            self.nodes[3].enumeratesigners,
         )
 
         # Handle error thrown by script
diff --git a/test/functional/test_framework/p2p.py b/test/functional/test_framework/p2p.py
index 7b384f2c2df84..775df88a73ce2 100755
--- a/test/functional/test_framework/p2p.py
+++ b/test/functional/test_framework/p2p.py
@@ -540,7 +540,7 @@ def peer_connect(self, *, services=P2P_SERVICES, send_version, **kwargs):
 
         return create_conn
 
-    def peer_accept_connection(self, *args, services=NODE_NETWORK | NODE_HEADERS_COMPRESSED, **kwargs):
+    def peer_accept_connection(self, *args, services=P2P_SERVICES, **kwargs):
         create_conn = super().peer_accept_connection(*args, **kwargs)
         self.peer_connect_send_version(services)
 
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index ae34b32819c6b..7977b17d4725b 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -157,6 +157,7 @@
     'wallet_listreceivedby.py --legacy-wallet',
     'wallet_listreceivedby.py --descriptors',
     'wallet_abandonconflict.py --legacy-wallet',
+    'p2p_dns_seeds.py',
     'wallet_abandonconflict.py --descriptors',
     'feature_csv_activation.py',
     'feature_reindex.py',
diff --git a/test/functional/tool_wallet.py b/test/functional/tool_wallet.py
index e7f9d6293f34e..25b2bd5cdf88f 100755
--- a/test/functional/tool_wallet.py
+++ b/test/functional/tool_wallet.py
@@ -352,7 +352,7 @@ def test_dump_createfromdump(self):
         non_exist_dump = os.path.join(self.nodes[0].datadir, "wallet.nodump")
         self.assert_raises_tool_error('Unknown wallet file format "notaformat" provided. Please provide one of "bdb" or "sqlite".', '-wallet=todump', '-format=notaformat', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
         self.assert_raises_tool_error('Dump file {} does not exist.'.format(non_exist_dump), '-wallet=todump', '-dumpfile={}'.format(non_exist_dump), 'createfromdump')
-        wallet_path = os.path.join(self.nodes[0].datadir, 'regtest/wallets/todump2')
+        wallet_path = os.path.join(self.nodes[0].datadir, 'regtest', 'wallets', 'todump2')
         self.assert_raises_tool_error('Failed to create database path \'{}\'. Database already exists.'.format(wallet_path), '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
         self.assert_raises_tool_error("The -descriptors option can only be used with the 'create' command.", '-descriptors', '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')