diff --git a/test/functional/README.md b/test/functional/README.md
--- a/test/functional/README.md
+++ b/test/functional/README.md
@@ -24,8 +24,8 @@
 - Use a module-level docstring to describe what the test is testing, and how it
   is testing it.
 - When subclassing the BitcoinTestFramwork, place overrides for the
-  `__init__()`, and `setup_xxxx()` methods at the top of the subclass, then
-  locally-defined helper methods, then the `run_test()` method.
+  `set_test_params()`, `add_options()` and `setup_xxxx()` methods at the top of
+  the subclass, then locally-defined helper methods, then the `run_test()` method.
 
 #### General test-writing advice
 
@@ -36,7 +36,7 @@
 - Avoid stop-starting the nodes multiple times during the test if possible. A
   stop-start takes several seconds, so doing it several times blows up the
   runtime of the test.
-- Set the `self.setup_clean_chain` variable in `__init__()` to control whether
+- Set the `self.setup_clean_chain` variable in `set_test_params()` to control whether
   or not to use the cached data directories. The cached data directories
   contain a 200-block pre-mined blockchain and wallets for four nodes. Each node
   has 25 mature blocks (25x50=1250 BTC) in its wallet.
diff --git a/test/functional/abandonconflict.py b/test/functional/abandonconflict.py
--- a/test/functional/abandonconflict.py
+++ b/test/functional/abandonconflict.py
@@ -10,11 +10,8 @@
 
 
 class AbandonConflictTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
         self.extra_args = [["-minrelaytxfee=0.00001"], []]
 
     def run_test(self):
@@ -81,8 +78,7 @@
         # Restart the node with a higher min relay fee so the parent tx is no longer in mempool
         # TODO: redo with eviction
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-minrelaytxfee=0.0001"])
+        self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])
 
         # Verify txs no longer in mempool
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
@@ -110,8 +106,7 @@
 
         # Verify that even with a low min relay fee, the tx is not reaccepted from wallet on startup once abandoned
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-minrelaytxfee=0.00001"])
+        self.start_node(0, extra_args=["-minrelaytxfee=0.00001"])
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         assert_equal(self.nodes[0].getbalance(), balance)
 
@@ -132,8 +127,7 @@
 
         # Remove using high relay fee again
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-minrelaytxfee=0.0001"])
+        self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         newbalance = self.nodes[0].getbalance()
         assert_equal(newbalance, balance - Decimal("24.9996"))
diff --git a/test/functional/abc-cmdline.py b/test/functional/abc-cmdline.py
--- a/test/functional/abc-cmdline.py
+++ b/test/functional/abc-cmdline.py
@@ -20,8 +20,7 @@
 
 class ABC_CmdLine_Test (BitcoinTestFramework):
 
-    def __init__(self):
-        super(ABC_CmdLine_Test, self).__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = False
 
@@ -44,8 +43,8 @@
         self.log.info("  Set to twice the default, i.e. %d bytes" %
                       (2 * LEGACY_MAX_BLOCK_SIZE))
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-excessiveblocksize=%d" % (2 * LEGACY_MAX_BLOCK_SIZE)])
+        self.start_node(0, ["-excessiveblocksize=%d" %
+                            (2 * LEGACY_MAX_BLOCK_SIZE)])
         self.check_excessive(2 * LEGACY_MAX_BLOCK_SIZE)
         # Check for EB correctness in the subver string
         self.check_subversion("/Bitcoin ABC:.*\(EB2\.0; .*\)/")
@@ -53,15 +52,15 @@
         self.log.info("  Attempt to set below legacy limit of 1MB - try %d bytes" %
                       LEGACY_MAX_BLOCK_SIZE)
         self.stop_node(0)
-        self.assert_start_raises_init_error(0, self.options.tmpdir, [
-                                            "-excessiveblocksize=%d" % LEGACY_MAX_BLOCK_SIZE], 'Error: Excessive block size must be > 1,000,000 bytes (1MB)')
+        self.assert_start_raises_init_error(
+            0, ["-excessiveblocksize=%d" % LEGACY_MAX_BLOCK_SIZE], 'Error: Excessive block size must be > 1,000,000 bytes (1MB)')
         self.log.info("  Attempt to set below blockmaxsize (mining limit)")
-        self.assert_start_raises_init_error(0, self.options.tmpdir, [
-                                            '-blockmaxsize=1500000', '-excessiveblocksize=1300000'], 'Error: ' + MAX_GENERATED_BLOCK_SIZE_ERROR)
+        self.assert_start_raises_init_error(
+            0, ['-blockmaxsize=1500000', '-excessiveblocksize=1300000'], 'Error: ' + MAX_GENERATED_BLOCK_SIZE_ERROR)
 
         # Make sure we leave the test with a node running as this is what thee
         # framework expects.
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [])
+        self.start_node(0, [])
 
     def run_test(self):
         # Run tests on -excessiveblocksize option
diff --git a/test/functional/abc-p2p-fullblocktest.py b/test/functional/abc-p2p-fullblocktest.py
--- a/test/functional/abc-p2p-fullblocktest.py
+++ b/test/functional/abc-p2p-fullblocktest.py
@@ -66,9 +66,9 @@
     # Change the "outcome" variable from each TestInstance object to only do
     # the comparison.
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
+        self.setup_clean_chain = True
         self.block_heights = {}
         self.coinbase_key = CECKey()
         self.coinbase_key.set_secretbytes(b"fatstacks")
diff --git a/test/functional/abc-rpc.py b/test/functional/abc-rpc.py
--- a/test/functional/abc-rpc.py
+++ b/test/functional/abc-rpc.py
@@ -18,8 +18,7 @@
 
 class ABC_RPC_Test (BitcoinTestFramework):
 
-    def __init__(self):
-        super(ABC_RPC_Test, self).__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.tip = None
         self.setup_clean_chain = True
diff --git a/test/functional/assumevalid.py b/test/functional/assumevalid.py
--- a/test/functional/assumevalid.py
+++ b/test/functional/assumevalid.py
@@ -56,16 +56,16 @@
 
 
 class AssumeValidTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
     def setup_network(self):
+        self.add_nodes(3)
         # Start node0. We don't start the other nodes yet since
         # we need to pre-mine a block with an invalid transaction
         # signature so we can pass in the block hash as assumevalid.
-        self.nodes = [self.start_node(0, self.options.tmpdir)]
+        self.start_node(0)
 
     def send_blocks_until_disconnected(self, node):
         """Keep sending blocks to the node until we're disconnected."""
@@ -171,16 +171,14 @@
             height += 1
 
         # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
-        self.nodes.append(self.start_node(1, self.options.tmpdir,
-                                          ["-assumevalid=" + hex(block102.sha256)]))
+        self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)])
         node1 = BaseNode()  # connects to node1
         connections.append(
             NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
         node1.add_connection(connections[1])
         node1.wait_for_verack()
 
-        self.nodes.append(self.start_node(2, self.options.tmpdir,
-                                          ["-assumevalid=" + hex(block102.sha256)]))
+        self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
         node2 = BaseNode()  # connects to node2
         connections.append(
             NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
diff --git a/test/functional/bip65-cltv-p2p.py b/test/functional/bip65-cltv-p2p.py
--- a/test/functional/bip65-cltv-p2p.py
+++ b/test/functional/bip65-cltv-p2p.py
@@ -65,9 +65,7 @@
 
 
 class BIP65Test(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [
             ['-promiscuousmempoolflags=1', '-whitelist=127.0.0.1']]
diff --git a/test/functional/bip68-112-113-p2p.py b/test/functional/bip68-112-113-p2p.py
--- a/test/functional/bip68-112-113-p2p.py
+++ b/test/functional/bip68-112-113-p2p.py
@@ -96,10 +96,9 @@
 
 
 class BIP68_112_113Test(ComparisonTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
+        self.setup_clean_chain = True
         self.extra_args = [['-whitelist=127.0.0.1', '-blockversion=4']]
 
     def run_test(self):
diff --git a/test/functional/bip68-sequence.py b/test/functional/bip68-sequence.py
--- a/test/functional/bip68-sequence.py
+++ b/test/functional/bip68-sequence.py
@@ -23,13 +23,10 @@
 
 
 class BIP68Test(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
         self.extra_args = [["-blockprioritypercentage=0"],
-                           ["-acceptnonstdtxn=0", "-blockprioritypercentage=0"]]
+                           ["-blockprioritypercentage=0", "-acceptnonstdtxn=0"]]
 
     def run_test(self):
         self.relayfee = self.nodes[0].getnetworkinfo()["relayfee"]
diff --git a/test/functional/bip9-softforks.py b/test/functional/bip9-softforks.py
--- a/test/functional/bip9-softforks.py
+++ b/test/functional/bip9-softforks.py
@@ -30,11 +30,10 @@
 
 
 class BIP9SoftForksTest(ComparisonTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [['-whitelist=127.0.0.1']]
+        self.setup_clean_chain = True
 
     def run_test(self):
         self.test = TestManager(self, self.options.tmpdir)
@@ -212,6 +211,7 @@
         # Restart all
         self.test.clear_all_connections()
         self.stop_nodes()
+        self.nodes = []
         shutil.rmtree(self.options.tmpdir + "/node0")
         self.setup_chain()
         self.setup_network()
diff --git a/test/functional/bipdersig-p2p.py b/test/functional/bipdersig-p2p.py
--- a/test/functional/bipdersig-p2p.py
+++ b/test/functional/bipdersig-p2p.py
@@ -52,9 +52,7 @@
 
 
 class BIP66Test(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [
             ['-promiscuousmempoolflags=1', '-whitelist=127.0.0.1']]
diff --git a/test/functional/bitcoin_cli.py b/test/functional/bitcoin_cli.py
--- a/test/functional/bitcoin_cli.py
+++ b/test/functional/bitcoin_cli.py
@@ -9,8 +9,7 @@
 
 class TestBitcoinCli(BitcoinTestFramework):
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
diff --git a/test/functional/blockchain.py b/test/functional/blockchain.py
--- a/test/functional/blockchain.py
+++ b/test/functional/blockchain.py
@@ -34,9 +34,7 @@
 
 
 class BlockchainTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = False
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [['-stopatheight=207']]
 
@@ -174,7 +172,7 @@
             pass  # The node already shut down before response
         self.log.debug('Node should stop at this height...')
         self.nodes[0].process.wait(timeout=BITCOIND_PROC_WAIT_TIMEOUT)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir)
+        self.start_node(0)
         assert_equal(self.nodes[0].getblockcount(), 207)
 
 
diff --git a/test/functional/create_cache.py b/test/functional/create_cache.py
--- a/test/functional/create_cache.py
+++ b/test/functional/create_cache.py
@@ -13,13 +13,10 @@
 
 
 class CreateCache(BitcoinTestFramework):
+    # Test network and test nodes are not required:
 
-    def __init__(self):
-        super().__init__()
-
-        # Test network and test nodes are not required:
+    def set_test_params(self):
         self.num_nodes = 0
-        self.nodes = []
 
     def setup_network(self):
         pass
diff --git a/test/functional/dbcrash.py b/test/functional/dbcrash.py
--- a/test/functional/dbcrash.py
+++ b/test/functional/dbcrash.py
@@ -44,8 +44,7 @@
 
 
 class ChainstateWriteCrashTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 4
         self.setup_clean_chain = False
 
@@ -68,8 +67,8 @@
 
     def setup_network(self):
         # Need a bit of extra time for the nodes to start up for this test
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, self.extra_args, timewait=90)
+        self.add_nodes(self.num_nodes, extra_args=self.extra_args, timewait=90)
+        self.start_nodes()
         # Leave them unconnected, we'll use submitblock directly in this test
 
     def restart_node(self, node_index, expected_tip):
@@ -82,8 +81,7 @@
         while time.time() - time_start < 120:
             try:
                 # Any of these RPC calls could throw due to node crash
-                self.nodes[node_index] = self.start_node(
-                    node_index, self.options.tmpdir, self.extra_args[node_index], timewait=90)
+                self.start_node(node_index)
                 self.nodes[node_index].waitforblock(expected_tip)
                 utxo_hash = self.nodes[node_index].gettxoutsetinfo()[
                     'hash_serialized']
diff --git a/test/functional/decodescript.py b/test/functional/decodescript.py
--- a/test/functional/decodescript.py
+++ b/test/functional/decodescript.py
@@ -10,11 +10,7 @@
 
 
 class DecodeScriptTest(BitcoinTestFramework):
-
-    """Tests decoding scripts via RPC command "decodescript"."""
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
diff --git a/test/functional/disablewallet.py b/test/functional/disablewallet.py
--- a/test/functional/disablewallet.py
+++ b/test/functional/disablewallet.py
@@ -12,9 +12,7 @@
 
 
 class DisableWalletTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [["-disablewallet"]]
diff --git a/test/functional/disconnect_ban.py b/test/functional/disconnect_ban.py
--- a/test/functional/disconnect_ban.py
+++ b/test/functional/disconnect_ban.py
@@ -14,11 +14,8 @@
 
 
 class DisconnectBanTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
 
     def run_test(self):
         self.log.info("Test setban and listbanned RPCs")
@@ -73,8 +70,8 @@
         wait_until(lambda: len(self.nodes[1].listbanned()) == 3)
 
         self.stop_node(1)
+        self.start_node(1)
 
-        self.nodes[1] = self.start_node(1, self.options.tmpdir)
         listAfterShutdown = self.nodes[1].listbanned()
         assert_equal("127.0.0.0/24", listAfterShutdown[0]['address'])
         assert_equal("127.0.0.0/32", listAfterShutdown[1]['address'])
diff --git a/test/functional/example_test.py b/test/functional/example_test.py
--- a/test/functional/example_test.py
+++ b/test/functional/example_test.py
@@ -73,21 +73,19 @@
 class ExampleTest(BitcoinTestFramework):
     # Each functional test is a subclass of the BitcoinTestFramework class.
 
-    # Override the __init__(), add_options(), setup_chain(), setup_network()
+    # Override the set_test_params(), add_options(), setup_chain(), setup_network()
     # and setup_nodes() methods to customize the test setup as required.
 
-    def __init__(self):
-        """Initialize the test
+    def set_test_params(self):
+        """Override test parameters for your individual test.
 
-        Call super().__init__() first, and then override any test parameters
-        for your individual test."""
-        super().__init__()
+        This method must be overridden and num_nodes must be exlicitly set."""
         self.setup_clean_chain = True
         self.num_nodes = 3
         # Use self.extra_args to change command-line arguments for the nodes
         self.extra_args = [[], ["-logips"], []]
 
-        # self.log.info("I've finished __init__")  # Oops! Can't run self.log before run_test()
+        # self.log.info("I've finished set_test_params")  # Oops! Can't run self.log before run_test()
 
     # Use add_options() to add specific command-line options for your test.
     # In practice this is not used very much, since the tests are mostly written
diff --git a/test/functional/forknotify.py b/test/functional/forknotify.py
--- a/test/functional/forknotify.py
+++ b/test/functional/forknotify.py
@@ -12,29 +12,19 @@
 import time
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
 
 
 class ForkNotifyTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
 
     def setup_network(self):
-        self.nodes = []
         self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
         with open(self.alert_filename, 'w', encoding='utf8'):
             pass  # Just open then close to create zero-length file
-        self.nodes.append(self.start_node(0, self.options.tmpdir,
-                                          ["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]))
-        # Node1 mines block.version=211 blocks
-        self.nodes.append(self.start_node(1, self.options.tmpdir,
-                                          ["-blockversion=211"]))
-        connect_nodes(self.nodes[1], 0)
-
-        self.sync_all()
+        self.extra_args = [["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""],
+                           ["-blockversion=211"]]
+        super().setup_network()
 
     def run_test(self):
         # Mine 51 up-version blocks
diff --git a/test/functional/fundrawtransaction.py b/test/functional/fundrawtransaction.py
--- a/test/functional/fundrawtransaction.py
+++ b/test/functional/fundrawtransaction.py
@@ -16,11 +16,9 @@
 
 
 class RawTransactionsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = True
+    def set_test_params(self):
         self.num_nodes = 4
+        self.setup_clean_chain = True
 
     def setup_network(self, split=False):
         self.setup_nodes()
@@ -460,11 +458,11 @@
         #
         # locked wallet test
         self.stop_node(0)
+        self.nodes[1].node_encrypt_wallet("test")
         self.stop_node(2)
         self.stop_node(3)
-        self.nodes[1].node_encrypt_wallet("test")
 
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)
+        self.start_nodes()
         # This test is not meant to test fee estimation and we'd like
         # to be sure all txs are sent at a consistent desired feerate
         for node in self.nodes:
diff --git a/test/functional/getblocktemplate_longpoll.py b/test/functional/getblocktemplate_longpoll.py
--- a/test/functional/getblocktemplate_longpoll.py
+++ b/test/functional/getblocktemplate_longpoll.py
@@ -26,15 +26,8 @@
 
 
 class GetBlockTemplateLPTest(BitcoinTestFramework):
-
-    '''
-    Test longpolling with getblocktemplate.
-    '''
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
 
     def run_test(self):
         self.log.info(
diff --git a/test/functional/getchaintips.py b/test/functional/getchaintips.py
--- a/test/functional/getchaintips.py
+++ b/test/functional/getchaintips.py
@@ -12,14 +12,10 @@
 
 
 class GetChainTipsTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 4
-        self.setup_clean_chain = False
 
     def run_test(self):
-
         tips = self.nodes[0].getchaintips()
         assert_equal(len(tips), 1)
         assert_equal(tips[0]['branchlen'], 0)
diff --git a/test/functional/high_priority_transaction.py b/test/functional/high_priority_transaction.py
--- a/test/functional/high_priority_transaction.py
+++ b/test/functional/high_priority_transaction.py
@@ -15,9 +15,7 @@
 
 class HighPriorityTransactionTest(BitcoinTestFramework):
 
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = True
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [["-blockprioritypercentage=0", "-limitfreerelay=2"]]
 
@@ -80,8 +78,9 @@
 
         # restart with default blockprioritypercentage
         self.stop_nodes()
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir,
-                                      [["-limitfreerelay=2"]])
+        self.nodes = []
+        self.add_nodes(self.num_nodes, [["-limitfreerelay=2"]])
+        self.start_nodes()
 
         # second test step: default reserved prio space in block (100K).
         # the mempool size is about 25K this means that all txns will be
diff --git a/test/functional/httpbasics.py b/test/functional/httpbasics.py
--- a/test/functional/httpbasics.py
+++ b/test/functional/httpbasics.py
@@ -15,11 +15,8 @@
 
 
 class HTTPBasicsTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 3
-        self.setup_clean_chain = False
 
     def setup_network(self):
         self.setup_nodes()
diff --git a/test/functional/import-rescan.py b/test/functional/import-rescan.py
--- a/test/functional/import-rescan.py
+++ b/test/functional/import-rescan.py
@@ -119,9 +119,7 @@
 
 
 class ImportRescanTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2 + len(IMPORT_NODES)
 
     def setup_network(self):
@@ -130,8 +128,8 @@
             if import_node.prune:
                 extra_args[i] += ["-prune=1"]
 
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, extra_args)
+        self.add_nodes(self.num_nodes, extra_args)
+        self.start_nodes()
         for i in range(1, self.num_nodes):
             connect_nodes(self.nodes[i], 0)
 
diff --git a/test/functional/importmulti.py b/test/functional/importmulti.py
--- a/test/functional/importmulti.py
+++ b/test/functional/importmulti.py
@@ -8,9 +8,7 @@
 
 
 class ImportMultiTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
 
@@ -480,7 +478,7 @@
 
         # restart nodes to check for proper serialization/deserialization of watch only address
         self.stop_nodes()
-        self.nodes = self.start_nodes(2, self.options.tmpdir)
+        self.start_nodes()
         address_assert = self.nodes[1].validateaddress(watchonly_address)
         assert_equal(address_assert['iswatchonly'], True)
         assert_equal(address_assert['ismine'], False)
diff --git a/test/functional/importprunedfunds.py b/test/functional/importprunedfunds.py
--- a/test/functional/importprunedfunds.py
+++ b/test/functional/importprunedfunds.py
@@ -8,9 +8,7 @@
 
 
 class ImportPrunedFundsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
 
diff --git a/test/functional/invalidateblock.py b/test/functional/invalidateblock.py
--- a/test/functional/invalidateblock.py
+++ b/test/functional/invalidateblock.py
@@ -12,9 +12,7 @@
 
 
 class InvalidateTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
diff --git a/test/functional/invalidblockrequest.py b/test/functional/invalidblockrequest.py
--- a/test/functional/invalidblockrequest.py
+++ b/test/functional/invalidblockrequest.py
@@ -27,9 +27,9 @@
     ''' Can either run this test as 1 node with expected answers, or two and compare them.
         Change the "outcome" variable from each TestInstance object to only do the comparison. '''
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
+        self.setup_clean_chain = True
 
     def run_test(self):
         test = TestManager(self, self.options.tmpdir)
diff --git a/test/functional/invalidtxrequest.py b/test/functional/invalidtxrequest.py
--- a/test/functional/invalidtxrequest.py
+++ b/test/functional/invalidtxrequest.py
@@ -18,15 +18,12 @@
 
 class InvalidTxRequestTest(ComparisonTestFramework):
 
-    '''
-    Can either run this test as 1 node with expected answers, or two and
-    compare them. Change the "outcome" variable from each TestInstance object
-    to only do the comparison.
-    '''
-
-    def __init__(self):
-        super().__init__()
+    ''' Can either run this test as 1 node with expected answers, or two and compare them. 
+        Change the "outcome" variable from each TestInstance object to only do the comparison. '''
+
+    def set_test_params(self):
         self.num_nodes = 1
+        self.setup_clean_chain = True
 
     def run_test(self):
         test = TestManager(self, self.options.tmpdir)
diff --git a/test/functional/keypool-topup.py b/test/functional/keypool-topup.py
--- a/test/functional/keypool-topup.py
+++ b/test/functional/keypool-topup.py
@@ -21,8 +21,7 @@
 
 
 class KeypoolRestoreTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [['-usehd=0'],
@@ -38,7 +37,7 @@
 
         shutil.copyfile(self.tmpdir + "/node1/regtest/wallet.dat",
                         self.tmpdir + "/wallet.bak")
-        self.nodes[1] = self.start_node(1, self.tmpdir, self.extra_args[1])
+        self.start_node(1, self.extra_args[1])
         connect_nodes_bi(self.nodes, 0, 1)
 
         self.log.info("Generate keys for wallet")
@@ -65,7 +64,7 @@
 
         self.log.info("Verify keypool is restored and balance is correct")
 
-        self.nodes[1] = self.start_node(1, self.tmpdir, self.extra_args[1])
+        self.start_node(1, self.extra_args[1])
         connect_nodes_bi(self.nodes, 0, 1)
         self.sync_all()
 
diff --git a/test/functional/keypool.py b/test/functional/keypool.py
--- a/test/functional/keypool.py
+++ b/test/functional/keypool.py
@@ -10,6 +10,8 @@
 
 
 class KeyPoolTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
 
     def run_test(self):
         nodes = self.nodes
@@ -23,7 +25,7 @@
         # Encrypt wallet and wait to terminate
         nodes[0].node_encrypt_wallet('test')
         # Restart node 0
-        nodes[0] = self.start_node(0, self.options.tmpdir)
+        self.start_node(0)
         # Keep creating keys
         addr = nodes[0].getnewaddress()
         addr_data = nodes[0].validateaddress(addr)
@@ -86,11 +88,6 @@
         assert_equal(wi['keypoolsize_hd_internal'], 100)
         assert_equal(wi['keypoolsize'], 100)
 
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = False
-        self.num_nodes = 1
-
 
 if __name__ == '__main__':
     KeyPoolTest().main()
diff --git a/test/functional/listsinceblock.py b/test/functional/listsinceblock.py
--- a/test/functional/listsinceblock.py
+++ b/test/functional/listsinceblock.py
@@ -8,11 +8,9 @@
 
 
 class ListSinceBlockTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = True
+    def set_test_params(self):
         self.num_nodes = 4
+        self.setup_clean_chain = True
 
     def run_test(self):
         '''
diff --git a/test/functional/listtransactions.py b/test/functional/listtransactions.py
--- a/test/functional/listtransactions.py
+++ b/test/functional/listtransactions.py
@@ -19,16 +19,9 @@
 
 
 class ListTransactionsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.num_nodes = 4
-        self.setup_clean_chain = False
-
-    def setup_nodes(self):
-        # This test requires mocktime
+    def set_test_params(self):
+        self.num_nodes = 2
         self.enable_mocktime()
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)
 
     def run_test(self):
         # Simple send, 0 to 1:
diff --git a/test/functional/maxuploadtarget.py b/test/functional/maxuploadtarget.py
--- a/test/functional/maxuploadtarget.py
+++ b/test/functional/maxuploadtarget.py
@@ -36,9 +36,7 @@
 
 
 class MaxUploadTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         # Start a node with maxuploadtarget of 200 MB (/24h)
@@ -159,8 +157,8 @@
         # stop and start node 0 with 1MB maxuploadtarget, whitelist 127.0.0.1
         self.log.info("Restarting nodes with -whitelist=127.0.0.1")
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-whitelist=127.0.0.1", "-maxuploadtarget=1"])
+        self.start_node(0, ["-whitelist=127.0.0.1",
+                            "-maxuploadtarget=1", "-blockmaxsize=999000"])
 
         # recreate/reconnect a test node
         test_nodes = [TestNode()]
diff --git a/test/functional/mempool-accept-txn.py b/test/functional/mempool-accept-txn.py
--- a/test/functional/mempool-accept-txn.py
+++ b/test/functional/mempool-accept-txn.py
@@ -37,9 +37,9 @@
     # Change the "outcome" variable from each TestInstance object to only do
     # the comparison.
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
+        self.setup_clean_chain = True
         self.block_heights = {}
         self.coinbase_key = CECKey()
         self.coinbase_key.set_secretbytes(b"horsebattery")
@@ -49,9 +49,8 @@
 
     def setup_network(self):
         self.extra_args = [['-norelaypriority']]
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir,
-                                      self.extra_args,
-                                      binary=[self.options.testbinary])
+        self.add_nodes(self.num_nodes, self.extra_args)
+        self.start_nodes()
 
     def add_options(self, parser):
         super().add_options(parser)
diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
--- a/test/functional/mempool_limit.py
+++ b/test/functional/mempool_limit.py
@@ -10,9 +10,7 @@
 
 
 class MempoolLimitTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -13,10 +13,8 @@
 
 
 class MempoolPackagesTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
         self.extra_args = [["-maxorphantx=1000"],
                            ["-maxorphantx=1000", "-limitancestorcount=5"]]
 
diff --git a/test/functional/mempool_persist.py b/test/functional/mempool_persist.py
--- a/test/functional/mempool_persist.py
+++ b/test/functional/mempool_persist.py
@@ -37,12 +37,8 @@
 
 
 class MempoolPersistTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        # We need 3 nodes for this test. Node1 does not have a persistent mempool.
+    def set_test_params(self):
         self.num_nodes = 3
-        self.setup_clean_chain = False
         self.extra_args = [[], ["-persistmempool=0"], []]
 
     def run_test(self):
@@ -67,9 +63,8 @@
         self.log.debug(
             "Stop-start node0 and node1. Verify that node0 has the transactions in its mempool and node1 does not.")
         self.stop_nodes()
-        self.nodes = []
-        self.nodes.append(self.start_node(0, self.options.tmpdir))
-        self.nodes.append(self.start_node(1, self.options.tmpdir))
+        self.start_node(0)
+        self.start_node(1)
         # Give bitcoind a second to reload the mempool
         time.sleep(1)
         wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
@@ -78,9 +73,7 @@
         self.log.debug(
             "Stop-start node0 with -persistmempool=0. Verify that it doesn't load its mempool.dat file.")
         self.stop_nodes()
-        self.nodes = []
-        self.nodes.append(self.start_node(
-            0, self.options.tmpdir, ["-persistmempool=0"]))
+        self.start_node(0, extra_args=["-persistmempool=0"])
         # Give bitcoind a second to reload the mempool
         time.sleep(1)
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
@@ -88,8 +81,7 @@
         self.log.debug(
             "Stop-start node0. Verify that it has the transactions in its mempool.")
         self.stop_nodes()
-        self.nodes = []
-        self.nodes.append(self.start_node(0, self.options.tmpdir))
+        self.start_node(0)
         wait_until(lambda: len(self.nodes[0].getrawmempool()) == 5)
 
 
diff --git a/test/functional/mempool_reorg.py b/test/functional/mempool_reorg.py
--- a/test/functional/mempool_reorg.py
+++ b/test/functional/mempool_reorg.py
@@ -15,12 +15,9 @@
 
 
 class MempoolCoinbaseTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
-        self.extra_args = [["-checkmempool"]] * self.num_nodes
+        self.extra_args = [["-checkmempool"]] * 2
 
     alert_filename = None  # Set by setup_network
 
diff --git a/test/functional/mempool_resurrect_test.py b/test/functional/mempool_resurrect_test.py
--- a/test/functional/mempool_resurrect_test.py
+++ b/test/functional/mempool_resurrect_test.py
@@ -15,13 +15,8 @@
 
 
 class MempoolCoinbaseTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
-        self.setup_clean_chain = False
-
-        # Just need one node for this test
         self.extra_args = [["-checkmempool"]]
 
     def run_test(self):
diff --git a/test/functional/mempool_spendcoinbase.py b/test/functional/mempool_spendcoinbase.py
--- a/test/functional/mempool_spendcoinbase.py
+++ b/test/functional/mempool_spendcoinbase.py
@@ -20,13 +20,8 @@
 
 
 class MempoolSpendCoinbaseTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
-        self.setup_clean_chain = False
-
-        # Just need one node for this test
         self.extra_args = [["-checkmempool"]]
 
     def run_test(self):
diff --git a/test/functional/merkle_blocks.py b/test/functional/merkle_blocks.py
--- a/test/functional/merkle_blocks.py
+++ b/test/functional/merkle_blocks.py
@@ -12,11 +12,9 @@
 
 
 class MerkleBlockTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = True
+    def set_test_params(self):
         self.num_nodes = 4
+        self.setup_clean_chain = True
         # Nodes 0/1 are "wallet" nodes, Nodes 2/3 are used for testing
         self.extra_args = [[], [], [], ["-txindex"]]
 
diff --git a/test/functional/mining.py b/test/functional/mining.py
--- a/test/functional/mining.py
+++ b/test/functional/mining.py
@@ -29,12 +29,7 @@
 
 
 class MiningTest(BitcoinTestFramework):
-    '''
-    Test block proposals with getblocktemplate.
-    '''
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = False
 
diff --git a/test/functional/multi_rpc.py b/test/functional/multi_rpc.py
--- a/test/functional/multi_rpc.py
+++ b/test/functional/multi_rpc.py
@@ -16,10 +16,7 @@
 
 
 class HTTPBasicsTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = False
+    def set_test_params(self):
         self.num_nodes = 2
 
     def setup_chain(self):
diff --git a/test/functional/multiwallet.py b/test/functional/multiwallet.py
--- a/test/functional/multiwallet.py
+++ b/test/functional/multiwallet.py
@@ -13,9 +13,7 @@
 
 
 class MultiWalletTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [
@@ -26,24 +24,23 @@
         self.stop_node(0)
 
         # should not initialize if there are duplicate wallets
-        self.assert_start_raises_init_error(0, self.options.tmpdir, [
-                                            '-wallet=w1', '-wallet=w1'], 'Error loading wallet w1. Duplicate -wallet filename specified.')
+        self.assert_start_raises_init_error(
+            0, ['-wallet=w1', '-wallet=w1'], 'Error loading wallet w1. Duplicate -wallet filename specified.')
 
         # should not initialize if wallet file is a directory
         os.mkdir(os.path.join(self.options.tmpdir, 'node0', 'regtest', 'w11'))
-        self.assert_start_raises_init_error(0, self.options.tmpdir, [
-                                            '-wallet=w11'], 'Error loading wallet w11. -wallet filename must be a regular file.')
+        self.assert_start_raises_init_error(
+            0, ['-wallet=w11'], 'Error loading wallet w11. -wallet filename must be a regular file.')
 
         # should not initialize if wallet file is a symlink
         wallet_dir = os.path.abspath(os.path.join(
             self.options.tmpdir, 'node0', 'regtest'))
         os.symlink(os.path.join(wallet_dir, 'w1'),
                    os.path.join(wallet_dir, 'w12'))
-        self.assert_start_raises_init_error(0, self.options.tmpdir, [
-                                            '-wallet=w12'], 'Error loading wallet w12. -wallet filename must be a regular file.')
+        self.assert_start_raises_init_error(
+            0, ['-wallet=w12'], 'Error loading wallet w12. -wallet filename must be a regular file.')
 
-        self.nodes[0] = self.start_node(
-            0, self.options.tmpdir, self.extra_args[0])
+        self.start_node(0, self.extra_args[0])
 
         w1 = self.nodes[0].get_wallet_rpc("w1")
         w2 = self.nodes[0].get_wallet_rpc("w2")
diff --git a/test/functional/net.py b/test/functional/net.py
--- a/test/functional/net.py
+++ b/test/functional/net.py
@@ -19,8 +19,7 @@
 
 
 class NetTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
 
diff --git a/test/functional/nulldummy.py b/test/functional/nulldummy.py
--- a/test/functional/nulldummy.py
+++ b/test/functional/nulldummy.py
@@ -41,8 +41,7 @@
 
 class NULLDUMMYTest(BitcoinTestFramework):
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
         self.extra_args = [['-whitelist=127.0.0.1', '-walletprematurewitness']]
diff --git a/test/functional/p2p-acceptblock.py b/test/functional/p2p-acceptblock.py
--- a/test/functional/p2p-acceptblock.py
+++ b/test/functional/p2p-acceptblock.py
@@ -64,8 +64,7 @@
                           default=os.getenv("BITCOIND", "bitcoind"),
                           help="bitcoind binary to test")
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [[], ["-whitelist=127.0.0.1"]]
diff --git a/test/functional/p2p-compactblocks.py b/test/functional/p2p-compactblocks.py
--- a/test/functional/p2p-compactblocks.py
+++ b/test/functional/p2p-compactblocks.py
@@ -97,9 +97,7 @@
 
 
 class CompactBlocksTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [[], ["-txindex"]]
diff --git a/test/functional/p2p-feefilter.py b/test/functional/p2p-feefilter.py
--- a/test/functional/p2p-feefilter.py
+++ b/test/functional/p2p-feefilter.py
@@ -45,11 +45,8 @@
 
 
 class FeeFilterTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
-        self.setup_clean_chain = False
 
     def run_test(self):
         node1 = self.nodes[1]
diff --git a/test/functional/p2p-fullblocktest.py b/test/functional/p2p-fullblocktest.py
--- a/test/functional/p2p-fullblocktest.py
+++ b/test/functional/p2p-fullblocktest.py
@@ -57,14 +57,11 @@
 
 
 class FullBlockTest(ComparisonTestFramework):
-
     # Can either run this test as 1 node with expected answers, or two and compare them.
-    # Change the "outcome" variable from each TestInstance object to only do
-    # the comparison.
-
-    def __init__(self):
-        super().__init__()
+    # Change the "outcome" variable from each TestInstance object to only do the comparison.
+    def set_test_params(self):
         self.num_nodes = 1
+        self.setup_clean_chain = True
         self.block_heights = {}
         self.coinbase_key = CECKey()
         self.coinbase_key.set_secretbytes(b"horsebattery")
diff --git a/test/functional/p2p-leaktests.py b/test/functional/p2p-leaktests.py
--- a/test/functional/p2p-leaktests.py
+++ b/test/functional/p2p-leaktests.py
@@ -126,9 +126,7 @@
 
 
 class P2PLeakTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [['-banscore=' + str(banscore)]]
 
diff --git a/test/functional/p2p-mempool.py b/test/functional/p2p-mempool.py
--- a/test/functional/p2p-mempool.py
+++ b/test/functional/p2p-mempool.py
@@ -9,9 +9,7 @@
 
 
 class P2PMempoolTests(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [["-peerbloomfilters=0"]]
diff --git a/test/functional/p2p-timeouts.py b/test/functional/p2p-timeouts.py
--- a/test/functional/p2p-timeouts.py
+++ b/test/functional/p2p-timeouts.py
@@ -35,9 +35,7 @@
 
 
 class TimeoutsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
diff --git a/test/functional/p2p-versionbits-warning.py b/test/functional/p2p-versionbits-warning.py
--- a/test/functional/p2p-versionbits-warning.py
+++ b/test/functional/p2p-versionbits-warning.py
@@ -34,9 +34,7 @@
 
 
 class VersionBitsWarningTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
@@ -124,8 +122,7 @@
         # Empty out the alert file
         with open(self.alert_filename, 'w', encoding='utf8') as _:
             pass
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, self.extra_args)
+        self.start_nodes()
 
         # Connecting one block should be enough to generate an error.
         self.nodes[0].generate(1)
@@ -138,8 +135,7 @@
         self.test_versionbits_in_alert_file()
 
         # Test framework expects the node to still be running...
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, self.extra_args)
+        self.start_nodes()
 
 
 if __name__ == '__main__':
diff --git a/test/functional/preciousblock.py b/test/functional/preciousblock.py
--- a/test/functional/preciousblock.py
+++ b/test/functional/preciousblock.py
@@ -42,9 +42,7 @@
 
 
 class PreciousTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
diff --git a/test/functional/prioritise_transaction.py b/test/functional/prioritise_transaction.py
--- a/test/functional/prioritise_transaction.py
+++ b/test/functional/prioritise_transaction.py
@@ -15,9 +15,7 @@
 
 
 class PrioritiseTransactionTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [["-printpriority=1"]]
diff --git a/test/functional/proxy_test.py b/test/functional/proxy_test.py
--- a/test/functional/proxy_test.py
+++ b/test/functional/proxy_test.py
@@ -43,11 +43,8 @@
 
 
 class ProxyTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 4
-        self.setup_clean_chain = False
 
     def setup_nodes(self):
         self.have_ipv6 = test_ipv6_local()
@@ -97,8 +94,8 @@
         if self.have_ipv6:
             args[3] = ['-listen', '-proxy=[%s]:%i' %
                        (self.conf3.addr), '-proxyrandomize=0', '-noonion']
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, extra_args=args)
+        self.add_nodes(self.num_nodes, extra_args=args)
+        self.start_nodes()
 
     def node_test(self, node, proxies, auth, test_onion=True):
         rv = []
diff --git a/test/functional/pruning.py b/test/functional/pruning.py
--- a/test/functional/pruning.py
+++ b/test/functional/pruning.py
@@ -29,9 +29,7 @@
 
 
 class PruneTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 6
 
@@ -60,6 +58,10 @@
         connect_nodes(self.nodes[0], 4)
         sync_blocks(self.nodes[0:5])
 
+    def setup_nodes(self):
+        self.add_nodes(self.num_nodes, self.extra_args, timewait=900)
+        self.start_nodes()
+
     def create_big_chain(self):
         # Start by creating some coinbases we can spend later
         self.nodes[1].generate(200)
@@ -108,8 +110,7 @@
             # Stopping node 0 also clears its mempool, so it doesn't have
             # node1's transactions to accidentally mine
             self.stop_node(0)
-            self.nodes[0] = self.start_node(
-                0, self.options.tmpdir, self.full_node_default_args, timewait=900)
+            self.start_node(0, extra_args=self.full_node_default_args)
             # Mine 24 blocks in node 1
             for i in range(24):
                 if j == 0:
@@ -142,8 +143,8 @@
         # block max size so we don't keep mining all our big mempool
         # transactions (from disconnected blocks)
         self.stop_node(1)
-        self.nodes[1] = self.start_node(1, self.options.tmpdir, [
-                                        "-maxreceivebuffer=20000", "-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"], timewait=900)
+        self.start_node(1, extra_args=[
+                        "-maxreceivebuffer=20000", "-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"])
 
         height = self.nodes[1].getblockcount()
         self.log.info("Current block height: %d" % height)
@@ -168,8 +169,8 @@
 
         # Reboot node1 to clear those giant tx's from mempool
         self.stop_node(1)
-        self.nodes[1] = self.start_node(1, self.options.tmpdir, [
-                                        "-maxreceivebuffer=20000", "-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"], timewait=900)
+        self.start_node(1, extra_args=[
+                        "-maxreceivebuffer=20000", "-blockmaxsize=5000", "-checkblocks=5", "-disablesafemode"])
 
         self.log.info("Generating new longer chain of 300 more blocks")
         self.nodes[1].generate(300)
@@ -257,16 +258,16 @@
 
     def manual_test(self, node_number, use_timestamp):
         # at this point, node has 995 blocks and has not yet run in prune mode
-        node = self.nodes[node_number] = self.start_node(
-            node_number, self.options.tmpdir, timewait=900)
+        self.start_node(node_number)
+        node = self.nodes[node_number]
         assert_equal(node.getblockcount(), 995)
-        assert_raises_jsonrpc(
-            -1, "not in prune mode", node.pruneblockchain, 500)
-        self.stop_node(node_number)
+        assert_raises_jsonrpc(-1, "not in prune mode",
+                              node.pruneblockchain, 500)
 
         # now re-start in manual pruning mode
-        node = self.nodes[node_number] = self.start_node(
-            node_number, self.options.tmpdir, ["-prune=1"], timewait=900)
+        self.stop_node(node_number)
+        self.start_node(node_number, extra_args=["-prune=1"])
+        node = self.nodes[node_number]
         assert_equal(node.getblockcount(), 995)
 
         def height(index):
@@ -353,8 +354,7 @@
         # stop node, start back up with auto-prune at 550MB, make sure still
         # runs
         self.stop_node(node_number)
-        self.nodes[node_number] = self.start_node(
-            node_number, self.options.tmpdir, ["-prune=550"], timewait=900)
+        self.start_node(node_number, extra_args=["-prune=550"])
 
         self.log.info("Success")
 
@@ -362,7 +362,7 @@
         # check that the pruning node's wallet is still in good shape
         self.log.info("Stop and start pruning node to trigger wallet rescan")
         self.stop_node(2)
-        self.nodes[2] = self.start_node(2, self.options.tmpdir, ["-prune=550"])
+        self.start_node(2, extra_args=["-prune=550"])
         self.log.info("Success")
 
         # check that wallet loads loads successfully when restarting a pruned node after IBD.
@@ -372,7 +372,7 @@
         nds = [self.nodes[0], self.nodes[5]]
         sync_blocks(nds, wait=5, timeout=300)
         self.stop_node(5)  # stop and start to trigger rescan
-        self.nodes[5] = self.start_node(5, self.options.tmpdir, ["-prune=550"])
+        self.start_node(5, extra_args=["-prune=550"])
         self.log.info("Success")
 
     def run_test(self):
diff --git a/test/functional/rawtransactions.py b/test/functional/rawtransactions.py
--- a/test/functional/rawtransactions.py
+++ b/test/functional/rawtransactions.py
@@ -19,9 +19,7 @@
 
 
 class RawTransactionsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
diff --git a/test/functional/receivedby.py b/test/functional/receivedby.py
--- a/test/functional/receivedby.py
+++ b/test/functional/receivedby.py
@@ -26,16 +26,9 @@
 
 
 class ReceivedByTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.num_nodes = 4
-        self.setup_clean_chain = False
-
-    def setup_nodes(self):
-        # This test requires mocktime
+    def set_test_params(self):
+        self.num_nodes = 2
         self.enable_mocktime()
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)
 
     def run_test(self):
         '''
diff --git a/test/functional/reindex.py b/test/functional/reindex.py
--- a/test/functional/reindex.py
+++ b/test/functional/reindex.py
@@ -13,8 +13,7 @@
 
 class ReindexTest(BitcoinTestFramework):
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
@@ -24,8 +23,7 @@
         self.stop_nodes()
         extra_args = [
             ["-reindex-chainstate" if justchainstate else "-reindex", "-checkblockindex=1"]]
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, extra_args)
+        self.start_nodes(extra_args)
         while self.nodes[0].getblockcount() < blockcount:
             time.sleep(0.1)
         assert_equal(self.nodes[0].getblockcount(), blockcount)
diff --git a/test/functional/resendwallettransactions.py b/test/functional/resendwallettransactions.py
--- a/test/functional/resendwallettransactions.py
+++ b/test/functional/resendwallettransactions.py
@@ -9,11 +9,9 @@
 
 
 class ResendWalletTransactionsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.extra_args = [['--walletbroadcast=false']]
+    def set_test_params(self):
         self.num_nodes = 1
+        self.extra_args = [['--walletbroadcast=false']]
 
     def run_test(self):
         # Should raise RPC_WALLET_ERROR (-4) if walletbroadcast is disabled.
@@ -22,7 +20,7 @@
 
         # Should return an empty array if there aren't unconfirmed wallet transactions.
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir)
+        self.start_node(0, extra_args=[])
         assert_equal(self.nodes[0].resendwallettransactions(), [])
 
         # Should return an array with the unconfirmed wallet transaction.
diff --git a/test/functional/rest.py b/test/functional/rest.py
--- a/test/functional/rest.py
+++ b/test/functional/rest.py
@@ -53,8 +53,7 @@
 class RESTTest (BitcoinTestFramework):
     FORMAT_SEPARATOR = "."
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
diff --git a/test/functional/rpcbind_test.py b/test/functional/rpcbind_test.py
--- a/test/functional/rpcbind_test.py
+++ b/test/functional/rpcbind_test.py
@@ -11,17 +11,12 @@
 
 
 class RPCBindTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
     def setup_network(self):
-        pass
-
-    def setup_nodes(self):
-        pass
+        self.add_nodes(self.num_nodes, None)
 
     def run_bind_test(self, allow_ips, connect_to, addresses, expected):
         '''
@@ -29,13 +24,14 @@
         then try to connect, and check if the set of bound addresses
         matches the expected set.
         '''
+        self.log.info("Bind test for %s" % str(addresses))
         expected = [(addr_to_hex(addr), port) for (addr, port) in expected]
         base_args = ['-disablewallet', '-nolisten']
         if allow_ips:
             base_args += ['-rpcallowip=' + x for x in allow_ips]
         binds = ['-rpcbind=' + addr for addr in addresses]
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, [
-                                      base_args + binds], connect_to)
+        self.nodes[0].rpchost = connect_to
+        self.start_node(0, base_args + binds)
         pid = self.nodes[0].process.pid
         assert_equal(set(get_bind_addrs(pid)), set(expected))
         self.stop_nodes()
@@ -45,10 +41,11 @@
         Start a node with rpcallow IP, and request getnetworkinfo
         at a non-localhost IP.
         '''
+        self.log.info("Allow IP test for %s:%d" % (rpchost, rpcport))
         base_args = ['-disablewallet', '-nolisten'] + \
             ['-rpcallowip=' + x for x in allow_ips]
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, [base_args])
+        self.nodes[0].rpchost = None
+        self.start_nodes([base_args])
         # connect to node through non-loopback interface
         node = get_rpc_proxy(rpc_url(get_datadir_path(self.options.tmpdir, 0), 0, "%s:%d" % (
             rpchost, rpcport)), 0, coveragedir=self.options.coveragedir)
diff --git a/test/functional/rpcnamedargs.py b/test/functional/rpcnamedargs.py
--- a/test/functional/rpcnamedargs.py
+++ b/test/functional/rpcnamedargs.py
@@ -16,14 +16,7 @@
 
 
 class NamedArgumentTest(BitcoinTestFramework):
-
-    """
-    Test named arguments on RPC calls.
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = False
+    def set_test_params(self):
         self.num_nodes = 1
 
     def run_test(self):
diff --git a/test/functional/sendheaders.py b/test/functional/sendheaders.py
--- a/test/functional/sendheaders.py
+++ b/test/functional/sendheaders.py
@@ -183,9 +183,7 @@
 
 
 class SendHeadersTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
 
diff --git a/test/functional/signmessages.py b/test/functional/signmessages.py
--- a/test/functional/signmessages.py
+++ b/test/functional/signmessages.py
@@ -8,11 +8,7 @@
 
 
 class SignMessagesTest(BitcoinTestFramework):
-
-    """Tests RPC commands for signing and verifying messages."""
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
diff --git a/test/functional/signrawtransactions.py b/test/functional/signrawtransactions.py
--- a/test/functional/signrawtransactions.py
+++ b/test/functional/signrawtransactions.py
@@ -8,11 +8,7 @@
 
 
 class SignRawTransactionsTest(BitcoinTestFramework):
-
-    """Tests transaction signing via RPC command "signrawtransaction"."""
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
diff --git a/test/functional/smartfees.py b/test/functional/smartfees.py
--- a/test/functional/smartfees.py
+++ b/test/functional/smartfees.py
@@ -157,74 +157,24 @@
 
 
 class EstimateFeeTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 3
-        self.setup_clean_chain = False
 
     def setup_network(self):
-        '''
+        """
         We'll setup the network to have 3 nodes that all mine with different parameters.
         But first we need to use one node to create a lot of small low priority outputs
         which we will use to generate our transactions.
-        '''
-        self.nodes = []
+        """
+        self.add_nodes(3, extra_args=[["-maxorphantx=1000", "-whitelist=127.0.0.1"],
+                                      ["-blockmaxsize=17000", "-maxorphantx=1000"],
+                                      ["-blockmaxsize=8000", "-maxorphantx=1000"]])
         # Use node0 to mine blocks for input splitting
-        self.nodes.append(self.start_node(0, self.options.tmpdir, ["-maxorphantx=1000",
-                                                                   "-whitelist=127.0.0.1"]))
-
-        self.log.info("This test is time consuming, please be patient")
-        self.log.info(
-            "Splitting inputs to small size so we can generate low priority tx's")
-        self.txouts = []
-        self.txouts2 = []
-        # Split a coinbase into two transaction puzzle outputs
-        split_inputs(self.nodes[0], self.nodes[
-                     0].listunspent(0), self.txouts, True)
-
-        # Mine
-        while (len(self.nodes[0].getrawmempool()) > 0):
-            self.nodes[0].generate(1)
-
-        # Repeatedly split those 2 outputs, doubling twice for each rep
-        # Use txouts to monitor the available utxo, since these won't be
-        # tracked in wallet
-        reps = 0
-        while (reps < 5):
-            # Double txouts to txouts2
-            while (len(self.txouts) > 0):
-                split_inputs(self.nodes[0], self.txouts, self.txouts2)
-            while (len(self.nodes[0].getrawmempool()) > 0):
-                self.nodes[0].generate(1)
-            # Double txouts2 to txouts
-            while (len(self.txouts2) > 0):
-                split_inputs(self.nodes[0], self.txouts2, self.txouts)
-            while (len(self.nodes[0].getrawmempool()) > 0):
-                self.nodes[0].generate(1)
-            reps += 1
-        self.log.info("Finished splitting")
-
-        # Now we can connect the other nodes, didn't want to connect them earlier
-        # so the estimates would not be affected by the splitting transactions
-        # Node1 mines small blocks but that are bigger than the expected transaction rate,
-        # and allows free transactions.
+        # Node1 mines small blocks but that are bigger than the expected transaction rate.
         # NOTE: the CreateNewBlock code starts counting block size at 1,000 bytes,
         # (17k is room enough for 110 or so transactions)
-        self.nodes.append(self.start_node(1, self.options.tmpdir,
-                                          ["-blockmaxsize=17000", "-maxorphantx=1000"]))
-        connect_nodes(self.nodes[1], 0)
-
         # Node2 is a stingy miner, that
         # produces too small blocks (room for only 55 or so transactions)
-        node2args = ["-blockprioritypercentage=0",
-                     "-blockmaxsize=8000", "-maxorphantx=1000"]
-
-        self.nodes.append(self.start_node(2, self.options.tmpdir, node2args))
-        connect_nodes(self.nodes[0], 2)
-        connect_nodes(self.nodes[2], 1)
-
-        self.sync_all()
 
     def transact_and_mine(self, numblocks, mining_node):
         min_fee = Decimal("0.00001")
@@ -255,10 +205,52 @@
             self.memutxo = newmem
 
     def run_test(self):
+        self.log.info("This test is time consuming, please be patient")
+        self.log.info("Splitting inputs so we can generate tx's")
+
         # Make log handler available to helper functions
         global log
         log = self.log
 
+        # Start node0
+        self.start_node(0)
+        self.txouts = []
+        self.txouts2 = []
+        # Split a coinbase into two transaction puzzle outputs
+        split_inputs(self.nodes[0], self.nodes[0].listunspent(
+            0), self.txouts, True)
+
+        # Mine
+        while (len(self.nodes[0].getrawmempool()) > 0):
+            self.nodes[0].generate(1)
+
+        # Repeatedly split those 2 outputs, doubling twice for each rep
+        # Use txouts to monitor the available utxo, since these won't be tracked in wallet
+        reps = 0
+        while (reps < 5):
+            # Double txouts to txouts2
+            while (len(self.txouts) > 0):
+                split_inputs(self.nodes[0], self.txouts, self.txouts2)
+            while (len(self.nodes[0].getrawmempool()) > 0):
+                self.nodes[0].generate(1)
+            # Double txouts2 to txouts
+            while (len(self.txouts2) > 0):
+                split_inputs(self.nodes[0], self.txouts2, self.txouts)
+            while (len(self.nodes[0].getrawmempool()) > 0):
+                self.nodes[0].generate(1)
+            reps += 1
+        self.log.info("Finished splitting")
+
+        # Now we can connect the other nodes, didn't want to connect them earlier
+        # so the estimates would not be affected by the splitting transactions
+        self.start_node(1)
+        self.start_node(2)
+        connect_nodes(self.nodes[1], 0)
+        connect_nodes(self.nodes[0], 2)
+        connect_nodes(self.nodes[2], 1)
+
+        self.sync_all()
+
         self.fees_per_kb = []
         self.memutxo = []
         self.confutxo = self.txouts  # Start with the set of confirmed txouts after splitting
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -49,62 +49,32 @@
 class BitcoinTestFramework():
     """Base class for a bitcoin test script.
 
-    Individual bitcoin test scripts should subclass this class and override the following methods:
+    Individual bitcoin test scripts should subclass this class and override the set_test_params() and run_test() methods.
+
+    Individual tests can also override the following methods to customize the test setup:
 
-    - __init__()
     - add_options()
     - setup_chain()
     - setup_network()
-    - run_test()
+    - setup_nodes()
 
-    The main() method should not be overridden.
+    The __init__() and main() methods should not be overridden.
 
     This class also contains various public and private helper methods."""
 
-    # Methods to override in subclass test scripts.
     def __init__(self):
-        self.num_nodes = 4
+        """Sets test framework defaults. Do not override this method. Instead, override the set_test_params() method"""
         self.setup_clean_chain = False
         self.nodes = []
         self.mocktime = 0
+        self.set_test_params()
 
-    def add_options(self, parser):
-        pass
-
-    def setup_chain(self):
-        self.log.info("Initializing test directory " + self.options.tmpdir)
-        if self.setup_clean_chain:
-            self._initialize_chain_clean(self.options.tmpdir, self.num_nodes)
-        else:
-            self._initialize_chain(self.options.tmpdir,
-                                   self.num_nodes, self.options.cachedir)
-
-    def setup_network(self):
-        '''
-        Sets up network including starting up nodes.
-        '''
-        self.setup_nodes()
-
-        # Connect the nodes as a "chain".  This allows us
-        # to split the network between nodes 1 and 2 to get
-        # two halves that can work on competing chains.
-
-        for i in range(self.num_nodes - 1):
-            connect_nodes_bi(self.nodes, i, i + 1)
-        self.sync_all()
-
-    def setup_nodes(self):
-        extra_args = None
-        if hasattr(self, "extra_args"):
-            extra_args = self.extra_args
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, extra_args)
-
-    def run_test(self):
-        raise NotImplementedError
+        assert hasattr(
+            self, "num_nodes"), "Test must set self.num_nodes in set_test_params()"
 
-    # Main function. This should not be overridden by the subclass test scripts.
     def main(self):
+        """Main function. This should not be overridden by the subclass test scripts."""
+
         parser = optparse.OptionParser(usage="%prog [options]")
         parser.add_option("--nocleanup", dest="nocleanup", default=False, action="store_true",
                           help="Leave bitcoinds and test.* datadir on exit or error")
@@ -211,27 +181,50 @@
             logging.shutdown()
             sys.exit(TEST_EXIT_FAILED)
 
-    # Public helper methods. These can be accessed by the subclass test scripts.
+    # Methods to override in subclass test scripts.
+    def set_test_params(self):
+        """Tests must this method to change default values for number of nodes, topology, etc"""
+        raise NotImplementedError
 
-    def start_node(self, i, dirname, extra_args=None, rpchost=None, timewait=None, binary=None, stderr=None):
-        """Start a bitcoind and return RPC connection to it"""
+    def add_options(self, parser):
+        """Override this method to add command-line options to the test"""
+        pass
 
-        if extra_args is None:
-            extra_args = []
-        if binary is None:
-            binary = os.getenv("BITCOIND", "bitcoind")
-        node = TestNode(i, dirname, extra_args, rpchost, timewait, binary,
-                        stderr, self.mocktime, coverage_dir=self.options.coveragedir)
-        node.start()
-        node.wait_for_rpc_connection()
+    def setup_chain(self):
+        """Override this method to customize blockchain setup"""
+        self.log.info("Initializing test directory " + self.options.tmpdir)
+        if self.setup_clean_chain:
+            self._initialize_chain_clean()
+        else:
+            self._initialize_chain()
 
-        if self.options.coveragedir is not None:
-            coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc)
+    def setup_network(self):
+        """Override this method to customize test network topology"""
+        self.setup_nodes()
+
+        # Connect the nodes as a "chain".  This allows us
+        # to split the network between nodes 1 and 2 to get
+        # two halves that can work on competing chains.
+        for i in range(self.num_nodes - 1):
+            connect_nodes_bi(self.nodes, i, i + 1)
+        self.sync_all()
+
+    def setup_nodes(self):
+        """Override this method to customize test node setup"""
+        extra_args = None
+        if hasattr(self, "extra_args"):
+            extra_args = self.extra_args
+        self.add_nodes(self.num_nodes, extra_args)
+        self.start_nodes()
 
-        return node
+    def run_test(self):
+        """Tests must override this method to define test logic"""
+        raise NotImplementedError
 
-    def start_nodes(self, num_nodes, dirname, extra_args=None, rpchost=None, timewait=None, binary=None):
-        """Start multiple bitcoinds, return RPC connections to them"""
+    # Public helper methods. These can be accessed by the subclass test scripts.
+
+    def add_nodes(self, num_nodes, extra_args=None, rpchost=None, timewait=None, binary=None):
+        """Instantiate TestNode objects"""
 
         if extra_args is None:
             extra_args = [[]] * num_nodes
@@ -239,13 +232,31 @@
             binary = [None] * num_nodes
         assert_equal(len(extra_args), num_nodes)
         assert_equal(len(binary), num_nodes)
-        nodes = []
+        for i in range(num_nodes):
+            self.nodes.append(TestNode(i, self.options.tmpdir, extra_args[i], rpchost, timewait=timewait,
+                                       binary=binary[i], stderr=None, mocktime=self.mocktime, coverage_dir=self.options.coveragedir))
+
+    def start_node(self, i, extra_args=None, stderr=None):
+        """Start a bitcoind"""
+
+        node = self.nodes[i]
+
+        node.start(extra_args, stderr)
+        node.wait_for_rpc_connection()
+
+        if self.options.coveragedir is not None:
+            coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc)
+
+    def start_nodes(self, extra_args=None):
+        """Start multiple bitcoinds"""
+
+        if extra_args is None:
+            extra_args = [None] * self.num_nodes
+        assert_equal(len(extra_args), self.num_nodes)
         try:
-            for i in range(num_nodes):
-                nodes.append(TestNode(i, dirname, extra_args[i], rpchost, timewait=timewait, binary=binary[i],
-                                      stderr=None, mocktime=self.mocktime, coverage_dir=self.options.coveragedir))
-                nodes[i].start()
-            for node in nodes:
+            for i, node in enumerate(self.nodes):
+                node.start(extra_args[i])
+            for node in self.nodes:
                 node.wait_for_rpc_connection()
         except:
             # If one node failed to start, stop the others
@@ -253,12 +264,10 @@
             raise
 
         if self.options.coveragedir is not None:
-            for node in nodes:
+            for node in self.nodes:
                 coverage.write_all_rpc_commands(
                     self.options.coveragedir, node.rpc)
 
-        return nodes
-
     def stop_node(self, i):
         """Stop a bitcoind test node"""
         self.nodes[i].stop_node()
@@ -276,10 +285,10 @@
             while not node.is_node_stopped():
                 time.sleep(0.1)
 
-    def assert_start_raises_init_error(self, i, dirname, extra_args=None, expected_msg=None):
+    def assert_start_raises_init_error(self, i, extra_args=None, expected_msg=None):
         with tempfile.SpooledTemporaryFile(max_size=2**16) as log_stderr:
             try:
-                self.start_node(i, dirname, extra_args, stderr=log_stderr)
+                self.start_node(i, extra_args, stderr=log_stderr)
                 self.stop_node(i)
             except Exception as e:
                 assert 'bitcoind exited' in str(e)  # node must have shutdown
@@ -374,16 +383,16 @@
             rpc_handler.setLevel(logging.DEBUG)
             rpc_logger.addHandler(rpc_handler)
 
-    def _initialize_chain(self, test_dir, num_nodes, cachedir):
+    def _initialize_chain(self):
         """Initialize a pre-mined blockchain for use by the test.
 
         Create a cache of a 200-block-long chain (with wallet) for MAX_NODES
         Afterward, create num_nodes copies from the cache."""
 
-        assert num_nodes <= MAX_NODES
+        assert self.num_nodes <= MAX_NODES
         create_cache = False
         for i in range(MAX_NODES):
-            if not os.path.isdir(os.path.join(cachedir, 'node' + str(i))):
+            if not os.path.isdir(os.path.join(self.options.cachedir, 'node' + str(i))):
                 create_cache = True
                 break
 
@@ -392,20 +401,21 @@
 
             # find and delete old cache directories if any exist
             for i in range(MAX_NODES):
-                if os.path.isdir(os.path.join(cachedir, "node" + str(i))):
-                    shutil.rmtree(os.path.join(cachedir, "node" + str(i)))
+                if os.path.isdir(os.path.join(self.options.cachedir, "node" + str(i))):
+                    shutil.rmtree(os.path.join(
+                        self.options.cachedir, "node" + str(i)))
 
             # Create cache directories, run bitcoinds:
             for i in range(MAX_NODES):
-                datadir = initialize_datadir(cachedir, i)
+                datadir = initialize_datadir(self.options.cachedir, i)
                 args = [os.getenv("BITCOIND", "bitcoind"), "-server",
                         "-keypool=1", "-datadir=" + datadir, "-discover=0"]
                 if i > 0:
                     args.append("-connect=127.0.0.1:" + str(p2p_port(0)))
-                self.nodes.append(TestNode(i, cachedir, extra_args=[], rpchost=None, timewait=None,
-                                           binary=None, stderr=None, mocktime=self.mocktime, coverage_dir=None))
+                self.nodes.append(TestNode(i, self.options.cachedir, extra_args=[
+                ], rpchost=None, timewait=None, binary=None, stderr=None, mocktime=self.mocktime, coverage_dir=None))
                 self.nodes[i].args = args
-                self.nodes[i].start()
+                self.start_node(i)
 
             # Wait for RPC connections to be ready
             for node in self.nodes:
@@ -434,25 +444,26 @@
             self.nodes = []
             self.disable_mocktime()
             for i in range(MAX_NODES):
-                os.remove(log_filename(cachedir, i, "debug.log"))
-                os.remove(log_filename(cachedir, i, "db.log"))
-                os.remove(log_filename(cachedir, i, "peers.dat"))
-                os.remove(log_filename(cachedir, i, "fee_estimates.dat"))
-
-        for i in range(num_nodes):
-            from_dir = os.path.join(cachedir, "node" + str(i))
-            to_dir = os.path.join(test_dir, "node" + str(i))
+                os.remove(log_filename(self.options.cachedir, i, "debug.log"))
+                os.remove(log_filename(self.options.cachedir, i, "db.log"))
+                os.remove(log_filename(self.options.cachedir, i, "peers.dat"))
+                os.remove(log_filename(
+                    self.options.cachedir, i, "fee_estimates.dat"))
+
+        for i in range(self.num_nodes):
+            from_dir = os.path.join(self.options.cachedir, "node" + str(i))
+            to_dir = os.path.join(self.options.tmpdir, "node" + str(i))
             shutil.copytree(from_dir, to_dir)
             # Overwrite port/rpcport in bitcoin.conf
-            initialize_datadir(test_dir, i)
+            initialize_datadir(self.options.tmpdir, i)
 
-    def _initialize_chain_clean(self, test_dir, num_nodes):
+    def _initialize_chain_clean(self):
         """Initialize empty blockchain for use by the test.
 
         Create an empty blockchain and num_nodes wallets.
         Useful if a test case wants complete control over initialization."""
-        for i in range(num_nodes):
-            initialize_datadir(test_dir, i)
+        for i in range(self.num_nodes):
+            initialize_datadir(self.options.tmpdir, i)
 
 
 class ComparisonTestFramework(BitcoinTestFramework):
@@ -463,8 +474,7 @@
     - 2 binaries: 1 test binary, 1 ref binary
     - n>2 binaries: 1 test binary, n-1 ref binaries"""
 
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
 
@@ -480,10 +490,10 @@
         extra_args = [['-whitelist=127.0.0.1']] * self.num_nodes
         if hasattr(self, "extra_args"):
             extra_args = self.extra_args
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, extra_args,
-            binary=[self.options.testbinary] +
-            [self.options.refbinary] * (self.num_nodes - 1))
+        self.add_nodes(self.num_nodes, extra_args,
+                       binary=[self.options.testbinary] +
+                       [self.options.refbinary] * (self.num_nodes - 1))
+        self.start_nodes()
 
 
 class SkipTest(Exception):
diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py
--- a/test/functional/test_framework/test_node.py
+++ b/test/functional/test_framework/test_node.py
@@ -68,10 +68,13 @@
         assert self.rpc_connected and self.rpc is not None, "Error: no RPC connection"
         return self.rpc.__getattr__(*args, **kwargs)
 
-    def start(self):
+    def start(self, extra_args=None, stderr=None):
         """Start the node."""
-        self.process = subprocess.Popen(
-            self.args + self.extra_args, stderr=self.stderr)
+        if extra_args is None:
+            extra_args = self.extra_args
+        if stderr is None:
+            stderr = self.stderr
+        self.process = subprocess.Popen(self.args + extra_args, stderr=stderr)
         self.running = True
         self.log.debug("bitcoind started, waiting for RPC to come up")
 
@@ -83,8 +86,8 @@
             assert self.process.poll(
             ) is None, "bitcoind exited with status %i during initialization" % self.process.returncode
             try:
-                self.rpc = get_rpc_proxy(rpc_url(
-                    self.datadir, self.index, self.rpchost), self.index, coveragedir=self.coverage_dir)
+                self.rpc = get_rpc_proxy(rpc_url(self.datadir, self.index, self.rpchost),
+                                         self.index, timeout=self.rpc_timeout, coveragedir=self.coverage_dir)
                 self.rpc.getblockcount()
                 # If the call to getblockcount() succeeds then the RPC connection is up
                 self.rpc_connected = True
diff --git a/test/functional/txn_clone.py b/test/functional/txn_clone.py
--- a/test/functional/txn_clone.py
+++ b/test/functional/txn_clone.py
@@ -12,11 +12,8 @@
 
 
 class TxnMallTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 4
-        self.setup_clean_chain = False
 
     def add_options(self, parser):
         parser.add_option(
diff --git a/test/functional/txn_doublespend.py b/test/functional/txn_doublespend.py
--- a/test/functional/txn_doublespend.py
+++ b/test/functional/txn_doublespend.py
@@ -12,11 +12,8 @@
 
 
 class TxnMallTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 4
-        self.setup_clean_chain = False
 
     def add_options(self, parser):
         parser.add_option(
diff --git a/test/functional/uptime.py b/test/functional/uptime.py
--- a/test/functional/uptime.py
+++ b/test/functional/uptime.py
@@ -13,9 +13,7 @@
 
 
 class UptimeTest(BitcoinTestFramework):
-    def __init__(self):
-        super().__init__()
-
+    def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
 
diff --git a/test/functional/wallet-accounts.py b/test/functional/wallet-accounts.py
--- a/test/functional/wallet-accounts.py
+++ b/test/functional/wallet-accounts.py
@@ -8,9 +8,7 @@
 
 
 class WalletAccountsTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.extra_args = [[]]
diff --git a/test/functional/wallet-dump.py b/test/functional/wallet-dump.py
--- a/test/functional/wallet-dump.py
+++ b/test/functional/wallet-dump.py
@@ -53,10 +53,7 @@
 
 
 class WalletDumpTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = False
+    def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [["-keypool=90"]]
 
@@ -65,8 +62,8 @@
         # longer than the default 30 seconds due to an expensive
         # CWallet::TopUpKeyPool call, and the encryptwallet RPC made later in
         # the test often takes even longer.
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, self.extra_args, timewait=60)
+        self.add_nodes(self.num_nodes, self.extra_args, timewait=60)
+        self.start_nodes()
 
     def run_test(self):
         tmpdir = self.options.tmpdir
@@ -95,8 +92,7 @@
 
         # encrypt wallet, restart, unlock and dump
         self.nodes[0].node_encrypt_wallet('test')
-        self.nodes[0] = self.start_node(
-            0, self.options.tmpdir, self.extra_args[0])
+        self.start_node(0)
         self.nodes[0].walletpassphrase('test', 10)
         # Should be a no-op:
         self.nodes[0].keypoolrefill()
diff --git a/test/functional/wallet-encryption.py b/test/functional/wallet-encryption.py
--- a/test/functional/wallet-encryption.py
+++ b/test/functional/wallet-encryption.py
@@ -14,9 +14,7 @@
 
 
 class WalletEncryptionTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
 
@@ -32,7 +30,7 @@
 
         # Encrypt the wallet
         self.nodes[0].node_encrypt_wallet(passphrase)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir)
+        self.start_node(0)
 
         # Test that the wallet is encrypted
         assert_raises_jsonrpc(-13, "Please enter the wallet passphrase with walletpassphrase first",
diff --git a/test/functional/wallet-hd.py b/test/functional/wallet-hd.py
--- a/test/functional/wallet-hd.py
+++ b/test/functional/wallet-hd.py
@@ -12,9 +12,7 @@
 
 
 class WalletHDTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [['-usehd=0'], ['-usehd=1', '-keypool=0']]
@@ -25,9 +23,8 @@
         # Make sure can't switch off usehd after wallet creation
         self.stop_node(1)
         self.assert_start_raises_init_error(
-            1, self.options.tmpdir, ['-usehd=0'], 'already existing HD wallet')
-        self.nodes[1] = self.start_node(
-            1, self.options.tmpdir, self.extra_args[1])
+            1, ['-usehd=0'], 'already existing HD wallet')
+        self.start_node(1)
         connect_nodes_bi(self.nodes, 0, 1)
 
         # Make sure we use hd, keep masterkeyid
@@ -80,8 +77,7 @@
         shutil.rmtree(tmpdir + "/node1/regtest/chainstate")
         shutil.copyfile(tmpdir + "/hd.bak", tmpdir +
                         "/node1/regtest/wallet.dat")
-        self.nodes[1] = self.start_node(
-            1, self.options.tmpdir, self.extra_args[1])
+        self.start_node(1)
 
         # Assert that derivation is deterministic
         hd_add_2 = None
@@ -96,8 +92,7 @@
 
         # Needs rescan
         self.stop_node(1)
-        self.nodes[1] = self.start_node(
-            1, self.options.tmpdir, self.extra_args[1] + ['-rescan'])
+        self.start_node(1, extra_args=self.extra_args[1] + ['-rescan'])
         assert_equal(self.nodes[1].getbalance(), num_hd_adds + 1)
 
         # send a tx and make sure its using the internal chain for the changeoutput
diff --git a/test/functional/wallet.py b/test/functional/wallet.py
--- a/test/functional/wallet.py
+++ b/test/functional/wallet.py
@@ -7,31 +7,30 @@
 from test_framework.util import *
 
 
-class WalletTest (BitcoinTestFramework):
-
-    def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byte, tx_size):
-        """Return curr_balance after asserting the fee was in range"""
-        fee = balance_with_fee - curr_balance
-        assert_fee_amount(fee, tx_size, fee_per_byte * 1000)
-        return curr_balance
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = True
+class WalletTest(BitcoinTestFramework):
+    def set_test_params(self):
         self.num_nodes = 4
-        self.extra_args = [['-usehd={:d}'.format(i % 2 == 0)]
-                           for i in range(4)]
+        self.setup_clean_chain = True
+        self.extra_args = [
+            ['-usehd={:d}'.format(i % 2 == 0)] for i in range(4)]
 
     def setup_network(self):
-        self.nodes = self.start_nodes(
-            3, self.options.tmpdir, self.extra_args[:3])
+        self.add_nodes(4, self.extra_args)
+        self.start_node(0)
+        self.start_node(1)
+        self.start_node(2)
         connect_nodes_bi(self.nodes, 0, 1)
         connect_nodes_bi(self.nodes, 1, 2)
         connect_nodes_bi(self.nodes, 0, 2)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
-    def run_test(self):
+    def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byte, tx_size):
+        """Return curr_balance after asserting the fee was in range"""
+        fee = balance_with_fee - curr_balance
+        assert_fee_amount(fee, tx_size, fee_per_byte * 1000)
+        return curr_balance
 
+    def run_test(self):
         # Check that there's no UTXO on none of the nodes
         assert_equal(len(self.nodes[0].listunspent()), 0)
         assert_equal(len(self.nodes[1].listunspent()), 0)
@@ -45,9 +44,9 @@
         assert_equal(walletinfo['immature_balance'], 50)
         assert_equal(walletinfo['balance'], 0)
 
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         self.nodes[1].generate(101)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         assert_equal(self.nodes[0].getbalance(), 50)
         assert_equal(self.nodes[1].getbalance(), 50)
@@ -67,7 +66,7 @@
 
         # Have node0 mine a block, thus it will collect its own fee.
         self.nodes[0].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         # Exercise locking of unspent outputs
         unspent_0 = self.nodes[2].listunspent()[0]
@@ -81,7 +80,7 @@
 
         # Have node1 generate 100 blocks (so node0 can recover the fee)
         self.nodes[1].generate(100)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         # node0 should end up with 100 btc in block rewards plus fees, but
         # minus the 21 plus fees sent to node2
@@ -111,7 +110,7 @@
 
         # Have node1 mine a block to confirm transactions:
         self.nodes[1].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         assert_equal(self.nodes[0].getbalance(), 0)
         assert_equal(self.nodes[2].getbalance(), 94)
@@ -123,7 +122,7 @@
         self.nodes[2].settxfee(fee_per_byte * 1000)
         txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
         self.nodes[2].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal(
             '84'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
         assert_equal(self.nodes[0].getbalance(), Decimal('10'))
@@ -131,7 +130,7 @@
         # Send 10 BTC with subtract fee from amount
         txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
         self.nodes[2].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal(
@@ -140,7 +139,7 @@
         # Sendmany 10 BTC
         txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [])
         self.nodes[2].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         node_0_bal += Decimal('10')
         node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal(
             '10'), fee_per_byte, count_bytes(self.nodes[2].getrawtransaction(txid)))
@@ -149,7 +148,7 @@
         # Sendmany 10 BTC with subtract fee from amount
         txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [address])
         self.nodes[2].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
         node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal(
@@ -161,10 +160,9 @@
         # EXPECT: nodes[3] should have those transactions in its mempool.
         txid1 = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
         txid2 = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1)
-        sync_mempools(self.nodes)
+        sync_mempools(self.nodes[0:2])
 
-        self.nodes.append(self.start_node(
-            3, self.options.tmpdir, self.extra_args[3]))
+        self.start_node(3)
         connect_nodes_bi(self.nodes, 0, 3)
         sync_blocks(self.nodes)
 
@@ -212,19 +210,19 @@
 
         # do some -walletbroadcast tests
         self.stop_nodes()
-        self.nodes = self.start_nodes(3, self.options.tmpdir, [
-                                      ["-walletbroadcast=0"], ["-walletbroadcast=0"], ["-walletbroadcast=0"]])
+        self.start_node(0, ["-walletbroadcast=0"])
+        self.start_node(1, ["-walletbroadcast=0"])
+        self.start_node(2, ["-walletbroadcast=0"])
         connect_nodes_bi(self.nodes, 0, 1)
         connect_nodes_bi(self.nodes, 1, 2)
         connect_nodes_bi(self.nodes, 0, 2)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         txIdNotBroadcasted = self.nodes[0].sendtoaddress(
             self.nodes[2].getnewaddress(), 2)
         txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
-        # mine a block, tx should not be in there
-        self.nodes[1].generate(1)
-        self.sync_all()
+        self.nodes[1].generate(1)  # mine a block, tx should not be in there
+        self.sync_all([self.nodes[0:3]])
         # should not be changed because tx was not broadcasted
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
 
@@ -232,7 +230,7 @@
         # balance
         self.nodes[1].sendrawtransaction(txObjNotBroadcasted['hex'])
         self.nodes[1].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         node_2_bal += 2
         txObjNotBroadcasted = self.nodes[0].gettransaction(txIdNotBroadcasted)
         assert_equal(self.nodes[2].getbalance(), node_2_bal)
@@ -243,14 +241,16 @@
 
         # restart the nodes with -walletbroadcast=1
         self.stop_nodes()
-        self.nodes = self.start_nodes(3, self.options.tmpdir)
+        self.start_node(0)
+        self.start_node(1)
+        self.start_node(2)
         connect_nodes_bi(self.nodes, 0, 1)
         connect_nodes_bi(self.nodes, 1, 2)
         connect_nodes_bi(self.nodes, 0, 2)
-        sync_blocks(self.nodes)
+        sync_blocks(self.nodes[0:3])
 
         self.nodes[0].generate(1)
-        sync_blocks(self.nodes)
+        sync_blocks(self.nodes[0:3])
         node_2_bal += 2
 
         # tx should be added to balance because after restarting the nodes tx
@@ -286,7 +286,7 @@
         address_to_import = self.nodes[2].getnewaddress()
         txid = self.nodes[0].sendtoaddress(address_to_import, 1)
         self.nodes[0].generate(1)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         # 2. Import address from node2 to node1
         self.nodes[1].importaddress(address_to_import)
@@ -312,15 +312,15 @@
         cbAddr = self.nodes[1].getnewaddress()
         blkHash = self.nodes[0].generatetoaddress(1, cbAddr)[0]
         cbTxId = self.nodes[0].getblock(blkHash)['tx'][0]
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
 
         # Check that the txid and balance is found by node1
         self.nodes[1].gettransaction(cbTxId)
 
         # check if wallet or blockchain maintenance changes the balance
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         blocks = self.nodes[0].generate(2)
-        self.sync_all()
+        self.sync_all([self.nodes[0:3]])
         balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
         block_count = self.nodes[0].getblockcount()
 
@@ -352,8 +352,9 @@
             self.log.info("check " + m)
             self.stop_nodes()
             # set lower ancestor limit for later
-            self.nodes = self.start_nodes(3, self.options.tmpdir, [
-                                          [m, "-limitancestorcount=" + str(chainlimit)]] * 3)
+            self.start_node(0, [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(1, [m, "-limitancestorcount=" + str(chainlimit)])
+            self.start_node(2, [m, "-limitancestorcount=" + str(chainlimit)])
             while m == '-reindex' and [block_count] * 3 != [self.nodes[i].getblockcount() for i in range(3)]:
                 # reindex will leave rpc warm up "early"; Wait for it to finish
                 time.sleep(0.1)
@@ -411,8 +412,8 @@
         # Try with walletrejectlongchains
         # Double chain limit but require combining inputs, so we pass SelectCoinsMinConf
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)])
+        self.start_node(0, extra_args=[
+                        "-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)])
 
         # wait for loadmempool
         timeout = 10
diff --git a/test/functional/walletbackup.py b/test/functional/walletbackup.py
--- a/test/functional/walletbackup.py
+++ b/test/functional/walletbackup.py
@@ -40,11 +40,9 @@
 
 
 class WalletBackupTest(BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
-        self.setup_clean_chain = True
+    def set_test_params(self):
         self.num_nodes = 4
+        self.setup_clean_chain = True
         # nodes 1, 2,3 are spenders, let's give them a keypool=100
         self.extra_args = [
             ["-keypool=100"], ["-keypool=100"], ["-keypool=100"], []]
@@ -83,9 +81,9 @@
 
     # As above, this mirrors the original bash test.
     def start_three(self):
-        self.nodes[0] = self.start_node(0, self.options.tmpdir)
-        self.nodes[1] = self.start_node(1, self.options.tmpdir)
-        self.nodes[2] = self.start_node(2, self.options.tmpdir)
+        self.start_node(0)
+        self.start_node(1)
+        self.start_node(2)
         connect_nodes(self.nodes[0], 3)
         connect_nodes(self.nodes[1], 3)
         connect_nodes(self.nodes[2], 3)
diff --git a/test/functional/zapwallettxes.py b/test/functional/zapwallettxes.py
--- a/test/functional/zapwallettxes.py
+++ b/test/functional/zapwallettxes.py
@@ -21,9 +21,7 @@
 
 
 class ZapWalletTXesTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
 
@@ -49,7 +47,7 @@
 
         # Stop-start node0. Both confirmed and unconfirmed transactions remain in the wallet.
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir)
+        self.start_node(0)
 
         assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)
         assert_equal(self.nodes[0].gettransaction(txid2)['txid'], txid2)
@@ -57,8 +55,7 @@
         # Stop node0 and restart with zapwallettxes and persistmempool. The unconfirmed
         # transaction is zapped from the wallet, but is re-added when the mempool is reloaded.
         self.stop_node(0)
-        self.nodes[0] = self.start_node(0, self.options.tmpdir, [
-                                        "-persistmempool=1", "-zapwallettxes=2"])
+        self.start_node(0, ["-persistmempool=1", "-zapwallettxes=2"])
 
         assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)
         assert_equal(self.nodes[0].gettransaction(txid2)['txid'], txid2)
@@ -66,8 +63,7 @@
         # Stop node0 and restart with zapwallettxes, but not persistmempool.
         # The unconfirmed transaction is zapped and is no longer in the wallet.
         self.stop_node(0)
-        self.nodes[0] = self.start_node(
-            0, self.options.tmpdir, ["-zapwallettxes=2"])
+        self.start_node(0, ["-zapwallettxes=2"])
 
         # tx1 is still be available because it was confirmed
         assert_equal(self.nodes[0].gettransaction(txid1)['txid'], txid1)
diff --git a/test/functional/zmq_test.py b/test/functional/zmq_test.py
--- a/test/functional/zmq_test.py
+++ b/test/functional/zmq_test.py
@@ -17,9 +17,7 @@
 
 
 class ZMQTest (BitcoinTestFramework):
-
-    def __init__(self):
-        super().__init__()
+    def set_test_params(self):
         self.num_nodes = 2
 
     def setup_nodes(self):
@@ -47,10 +45,10 @@
 
         ip_address = "tcp://127.0.0.1:28332"
         self.zmqSubSocket.connect(ip_address)
-        extra_args = [['-zmqpubhashtx=%s' %
-                       ip_address, '-zmqpubhashblock=%s' % ip_address], []]
-        self.nodes = self.start_nodes(
-            self.num_nodes, self.options.tmpdir, extra_args)
+        self.extra_args = [['-zmqpubhashtx=%s' %
+                            ip_address, '-zmqpubhashblock=%s' % ip_address], []]
+        self.add_nodes(self.num_nodes, self.extra_args)
+        self.start_nodes()
 
     def run_test(self):
         try: