diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 7cdeac02e..b10ea264b 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -1,62 +1,69 @@
 // Copyright (c) 2011-2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <script/standard.h>
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
 #include <test/util/wallet.h>
 #include <txmempool.h>
 #include <validation.h>
 
 #include <vector>
 
 static void AssembleBlock(benchmark::State &state) {
     const Config &config = GetConfig();
-    RegTestingSetup test_setup;
+    TestingSetup test_setup{
+        CBaseChainParams::REGTEST,
+        /* extra_args */
+        {
+            "-nodebuglogfile",
+            "-nodebug",
+        },
+    };
 
     const CScript redeemScript = CScript() << OP_DROP << OP_TRUE;
     const CScript SCRIPT_PUB =
         CScript() << OP_HASH160 << ToByteVector(CScriptID(redeemScript))
                   << OP_EQUAL;
 
     const CScript scriptSig = CScript() << std::vector<uint8_t>(100, 0xff)
                                         << ToByteVector(redeemScript);
 
     // Collect some loose transactions that spend the coinbases of our mined
     // blocks
     constexpr size_t NUM_BLOCKS{200};
     std::array<CTransactionRef, NUM_BLOCKS - COINBASE_MATURITY + 1> txs;
     for (size_t b = 0; b < NUM_BLOCKS; ++b) {
         CMutableTransaction tx;
         tx.vin.push_back(MineBlock(config, test_setup.m_node, SCRIPT_PUB));
         tx.vin.back().scriptSig = scriptSig;
         tx.vout.emplace_back(1337 * SATOSHI, SCRIPT_PUB);
         if (NUM_BLOCKS - b >= COINBASE_MATURITY) {
             txs.at(b) = MakeTransactionRef(tx);
         }
     }
 
     {
         // Required for ::AcceptToMemoryPool.
         LOCK(::cs_main);
 
         for (const auto &txr : txs) {
             TxValidationState vstate;
             bool ret{::AcceptToMemoryPool(config, *test_setup.m_node.mempool,
                                           vstate, txr,
                                           false /* bypass_limits */,
                                           /* nAbsurdFee */ Amount::zero())};
             assert(ret);
         }
     }
 
     while (state.KeepRunning()) {
         PrepareBlock(config, test_setup.m_node, SCRIPT_PUB);
     }
 }
 
 BENCHMARK(AssembleBlock, 700);
diff --git a/src/bench/duplicate_inputs.cpp b/src/bench/duplicate_inputs.cpp
index 00d496be0..3f7a54c5e 100644
--- a/src/bench/duplicate_inputs.cpp
+++ b/src/bench/duplicate_inputs.cpp
@@ -1,71 +1,78 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <pow/pow.h>
 #include <random.h>
 #include <script/scriptcache.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
 #include <validation.h>
 
 static void DuplicateInputs(benchmark::State &state) {
-    RegTestingSetup test_setup;
+    TestingSetup test_setup{
+        CBaseChainParams::REGTEST,
+        /* extra_args */
+        {
+            "-nodebuglogfile",
+            "-nodebug",
+        },
+    };
 
     const CScript SCRIPT_PUB{CScript(OP_TRUE)};
 
     const CChainParams &chainParams = Params();
     const Consensus::Params &consensusParams = chainParams.GetConsensus();
 
     CBlock block{};
     CMutableTransaction coinbaseTx{};
     CMutableTransaction naughtyTx{};
 
     LOCK(cs_main);
     CBlockIndex *pindexPrev = ::ChainActive().Tip();
     assert(pindexPrev != nullptr);
     block.nBits = GetNextWorkRequired(pindexPrev, &block, chainParams);
     block.nNonce = 0;
     auto nHeight = pindexPrev->nHeight + 1;
 
     // Make a coinbase TX
     coinbaseTx.vin.resize(1);
     coinbaseTx.vin[0].prevout = COutPoint();
     coinbaseTx.vout.resize(1);
     coinbaseTx.vout[0].scriptPubKey = SCRIPT_PUB;
     coinbaseTx.vout[0].nValue = GetBlockSubsidy(nHeight, consensusParams);
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
 
     naughtyTx.vout.resize(1);
     naughtyTx.vout[0].nValue = Amount::zero();
     naughtyTx.vout[0].scriptPubKey = SCRIPT_PUB;
 
     uint64_t n_inputs =
         ((MAX_TX_SIZE - CTransaction(naughtyTx).GetTotalSize()) / 41) - 100;
     for (uint64_t x = 0; x < (n_inputs - 1); ++x) {
         naughtyTx.vin.emplace_back(TxId(GetRandHash()), 0, CScript(), 0);
     }
     naughtyTx.vin.emplace_back(naughtyTx.vin.back());
 
     block.vtx.push_back(MakeTransactionRef(std::move(coinbaseTx)));
     block.vtx.push_back(MakeTransactionRef(std::move(naughtyTx)));
 
     block.hashMerkleRoot = BlockMerkleRoot(block);
 
     while (state.KeepRunning()) {
         BlockValidationState cvstate{};
         assert(!CheckBlock(block, cvstate, consensusParams,
                            BlockValidationOptions(GetConfig())
                                .withCheckPoW(false)
                                .withCheckMerkleRoot(false)));
         assert(cvstate.GetRejectReason() == "bad-txns-inputs-duplicate");
     }
 }
 
 BENCHMARK(DuplicateInputs, 10);
diff --git a/src/bench/mempool_eviction.cpp b/src/bench/mempool_eviction.cpp
index 595208e73..11f4263e2 100644
--- a/src/bench/mempool_eviction.cpp
+++ b/src/bench/mempool_eviction.cpp
@@ -1,121 +1,128 @@
 // Copyright (c) 2011-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
 #include <policy/policy.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
 
 static void AddTx(const CTransactionRef &tx, const Amount &nFee,
                   CTxMemPool &pool) EXCLUSIVE_LOCKS_REQUIRED(cs_main, pool.cs) {
     int64_t nTime = 0;
     unsigned int nHeight = 1;
     bool spendsCoinbase = false;
     unsigned int nSigOpCount = 1;
     LockPoints lp;
     pool.addUnchecked(CTxMemPoolEntry(tx, nFee, nTime, nHeight, spendsCoinbase,
                                       nSigOpCount, lp));
 }
 
 // Right now this is only testing eviction performance in an extremely small
 // mempool. Code needs to be written to generate a much wider variety of
 // unique transactions for a more meaningful performance measurement.
 static void MempoolEviction(benchmark::State &state) {
-    RegTestingSetup test_setup;
+    TestingSetup test_setup{
+        CBaseChainParams::REGTEST,
+        /* extra_args */
+        {
+            "-nodebuglogfile",
+            "-nodebug",
+        },
+    };
 
     CMutableTransaction tx1 = CMutableTransaction();
     tx1.vin.resize(1);
     tx1.vin[0].scriptSig = CScript() << OP_1;
     tx1.vout.resize(1);
     tx1.vout[0].scriptPubKey = CScript() << OP_1 << OP_EQUAL;
     tx1.vout[0].nValue = 10 * COIN;
 
     CMutableTransaction tx2 = CMutableTransaction();
     tx2.vin.resize(1);
     tx2.vin[0].scriptSig = CScript() << OP_2;
     tx2.vout.resize(1);
     tx2.vout[0].scriptPubKey = CScript() << OP_2 << OP_EQUAL;
     tx2.vout[0].nValue = 10 * COIN;
 
     CMutableTransaction tx3 = CMutableTransaction();
     tx3.vin.resize(1);
     tx3.vin[0].prevout = COutPoint(tx2.GetId(), 0);
     tx3.vin[0].scriptSig = CScript() << OP_2;
     tx3.vout.resize(1);
     tx3.vout[0].scriptPubKey = CScript() << OP_3 << OP_EQUAL;
     tx3.vout[0].nValue = 10 * COIN;
 
     CMutableTransaction tx4 = CMutableTransaction();
     tx4.vin.resize(2);
     tx4.vin[0].prevout = COutPoint();
     tx4.vin[0].scriptSig = CScript() << OP_4;
     tx4.vin[1].prevout = COutPoint();
     tx4.vin[1].scriptSig = CScript() << OP_4;
     tx4.vout.resize(2);
     tx4.vout[0].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
     tx4.vout[0].nValue = 10 * COIN;
     tx4.vout[1].scriptPubKey = CScript() << OP_4 << OP_EQUAL;
     tx4.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx5 = CMutableTransaction();
     tx5.vin.resize(2);
     tx5.vin[0].prevout = COutPoint(tx4.GetId(), 0);
     tx5.vin[0].scriptSig = CScript() << OP_4;
     tx5.vin[1].prevout = COutPoint();
     tx5.vin[1].scriptSig = CScript() << OP_5;
     tx5.vout.resize(2);
     tx5.vout[0].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
     tx5.vout[0].nValue = 10 * COIN;
     tx5.vout[1].scriptPubKey = CScript() << OP_5 << OP_EQUAL;
     tx5.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx6 = CMutableTransaction();
     tx6.vin.resize(2);
     tx6.vin[0].prevout = COutPoint(tx4.GetId(), 1);
     tx6.vin[0].scriptSig = CScript() << OP_4;
     tx6.vin[1].prevout = COutPoint();
     tx6.vin[1].scriptSig = CScript() << OP_6;
     tx6.vout.resize(2);
     tx6.vout[0].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
     tx6.vout[0].nValue = 10 * COIN;
     tx6.vout[1].scriptPubKey = CScript() << OP_6 << OP_EQUAL;
     tx6.vout[1].nValue = 10 * COIN;
 
     CMutableTransaction tx7 = CMutableTransaction();
     tx7.vin.resize(2);
     tx7.vin[0].prevout = COutPoint(tx5.GetId(), 0);
     tx7.vin[0].scriptSig = CScript() << OP_5;
     tx7.vin[1].prevout = COutPoint(tx6.GetId(), 0);
     tx7.vin[1].scriptSig = CScript() << OP_6;
     tx7.vout.resize(2);
     tx7.vout[0].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
     tx7.vout[0].nValue = 10 * COIN;
     tx7.vout[1].scriptPubKey = CScript() << OP_7 << OP_EQUAL;
     tx7.vout[1].nValue = 10 * COIN;
 
     CTxMemPool pool;
     LOCK2(cs_main, pool.cs);
     // Create transaction references outside the "hot loop"
     const CTransactionRef tx1_r{MakeTransactionRef(tx1)};
     const CTransactionRef tx2_r{MakeTransactionRef(tx2)};
     const CTransactionRef tx3_r{MakeTransactionRef(tx3)};
     const CTransactionRef tx4_r{MakeTransactionRef(tx4)};
     const CTransactionRef tx5_r{MakeTransactionRef(tx5)};
     const CTransactionRef tx6_r{MakeTransactionRef(tx6)};
     const CTransactionRef tx7_r{MakeTransactionRef(tx7)};
 
     while (state.KeepRunning()) {
         AddTx(tx1_r, 10000 * SATOSHI, pool);
         AddTx(tx2_r, 5000 * SATOSHI, pool);
         AddTx(tx3_r, 20000 * SATOSHI, pool);
         AddTx(tx4_r, 7000 * SATOSHI, pool);
         AddTx(tx5_r, 1000 * SATOSHI, pool);
         AddTx(tx6_r, 1100 * SATOSHI, pool);
         AddTx(tx7_r, 9000 * SATOSHI, pool);
         pool.TrimToSize(pool.DynamicMemoryUsage() * 3 / 4);
         pool.TrimToSize(GetSerializeSize(*tx1_r, PROTOCOL_VERSION));
     }
 }
 
 BENCHMARK(MempoolEviction, 41000);
diff --git a/src/bench/wallet_balance.cpp b/src/bench/wallet_balance.cpp
index 0b95ede0b..9f8459d61 100644
--- a/src/bench/wallet_balance.cpp
+++ b/src/bench/wallet_balance.cpp
@@ -1,87 +1,95 @@
 // Copyright (c) 2012-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <bench/bench.h>
 #include <config.h>
 #include <interfaces/chain.h>
 #include <node/context.h>
 #include <test/util/mining.h>
 #include <test/util/setup_common.h>
 #include <test/util/wallet.h>
 #include <validationinterface.h>
 #include <wallet/wallet.h>
 
 static void WalletBalance(benchmark::State &state, const bool set_dirty,
                           const bool add_watchonly, const bool add_mine) {
-    RegTestingSetup test_setup;
+    TestingSetup test_setup{
+        CBaseChainParams::REGTEST,
+        /* extra_args */
+        {
+            "-nodebuglogfile",
+            "-nodebug",
+        },
+    };
+
     const auto &ADDRESS_WATCHONLY = ADDRESS_BCHREG_UNSPENDABLE;
 
     const Config &config = GetConfig();
 
     NodeContext node;
     std::unique_ptr<interfaces::Chain> chain =
         interfaces::MakeChain(node, config.GetChainParams());
     CWallet wallet{chain.get(), WalletLocation(), WalletDatabase::CreateMock()};
     {
         wallet.SetupLegacyScriptPubKeyMan();
         bool first_run;
         if (wallet.LoadWallet(first_run) != DBErrors::LOAD_OK) {
             assert(false);
         }
     }
 
     auto handler = chain->handleNotifications({&wallet, [](CWallet *) {}});
 
     const std::optional<std::string> address_mine{
         add_mine ? std::optional<std::string>{getnewaddress(config, wallet)}
                  : std::nullopt};
     if (add_watchonly) {
         importaddress(wallet, ADDRESS_WATCHONLY);
     }
 
     for (int i = 0; i < 100; ++i) {
         generatetoaddress(config, test_setup.m_node,
                           address_mine.value_or(ADDRESS_WATCHONLY));
         generatetoaddress(config, test_setup.m_node, ADDRESS_WATCHONLY);
     }
     SyncWithValidationInterfaceQueue();
 
     // Cache
     auto bal = wallet.GetBalance();
 
     while (state.KeepRunning()) {
         if (set_dirty) {
             wallet.MarkDirty();
         }
         bal = wallet.GetBalance();
         if (add_mine) {
             assert(bal.m_mine_trusted > Amount::zero());
         }
         if (add_watchonly) {
             assert(bal.m_watchonly_trusted > Amount::zero());
         }
     }
 }
 
 static void WalletBalanceDirty(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ true, /* add_watchonly */ true,
                   /* add_mine */ true);
 }
 static void WalletBalanceClean(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ false, /* add_watchonly */ true,
                   /* add_mine */ true);
 }
 static void WalletBalanceMine(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ false, /* add_watchonly */ false,
                   /* add_mine */ true);
 }
 static void WalletBalanceWatch(benchmark::State &state) {
     WalletBalance(state, /* set_dirty */ false, /* add_watchonly */ true,
                   /* add_mine */ false);
 }
 
 BENCHMARK(WalletBalanceDirty, 2500);
 BENCHMARK(WalletBalanceClean, 8000);
 BENCHMARK(WalletBalanceMine, 16000);
 BENCHMARK(WalletBalanceWatch, 8000);