diff --git a/test/functional/mempool_reorg.py b/test/functional/mempool_reorg.py
index 3d17f81e9..066d03d2f 100755
--- a/test/functional/mempool_reorg.py
+++ b/test/functional/mempool_reorg.py
@@ -1,140 +1,140 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-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.
 """Test mempool re-org scenarios.
 
 Test re-org scenarios with a mempool that contains transactions
 that spend (directly or indirectly) coinbase transactions.
 """
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.wallet import MiniWallet
 
 
 class MempoolCoinbaseTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [
             # immediate tx relay
             ['-whitelist=noban@127.0.0.1', ],
             []
         ]
 
     def run_test(self):
         wallet = MiniWallet(self.nodes[0])
 
         # Start with a 200 block chain
         assert_equal(self.nodes[0].getblockcount(), 200)
 
         self.log.info("Add 4 coinbase utxos to the miniwallet")
         # Block 76 contains the first spendable coinbase txs.
         first_block = 76
-        wallet.scan_blocks(start=first_block, num=4)
+        wallet.rescan_utxos()
 
         # Three scenarios for re-orging coinbase spends in the memory pool:
         # 1. Direct coinbase spend  :  spend_1
         # 2. Indirect (coinbase spend in chain, child in mempool) : spend_2 and spend_2_1
         # 3. Indirect (coinbase and child both in chain) : spend_3 and spend_3_1
         # Use invalidateblock to make all of the above coinbase spends invalid (immature coinbase),
         # and make sure the mempool code behaves correctly.
         b = [
             self.nodes[0].getblockhash(n) for n in range(
                 first_block,
                 first_block + 4)]
         coinbase_txids = [self.nodes[0].getblock(h)['tx'][0] for h in b]
         utxo_1 = wallet.get_utxo(txid=coinbase_txids[1])
         utxo_2 = wallet.get_utxo(txid=coinbase_txids[2])
         utxo_3 = wallet.get_utxo(txid=coinbase_txids[3])
         self.log.info(
             "Create three transactions spending from coinbase utxos: spend_1, spend_2, spend_3")
         spend_1 = wallet.create_self_transfer(
             from_node=self.nodes[0], utxo_to_spend=utxo_1)
         spend_2 = wallet.create_self_transfer(
             from_node=self.nodes[0], utxo_to_spend=utxo_2)
         spend_3 = wallet.create_self_transfer(
             from_node=self.nodes[0], utxo_to_spend=utxo_3)
 
         self.log.info(
             "Create another transaction which is time-locked to two blocks in the future")
         utxo = wallet.get_utxo(txid=coinbase_txids[0])
         timelock_tx = wallet.create_self_transfer(
             from_node=self.nodes[0],
             utxo_to_spend=utxo,
             mempool_valid=False,
             locktime=self.nodes[0].getblockcount() + 2
         )['hex']
 
         self.log.info(
             "Check that the time-locked transaction is too immature to spend")
         assert_raises_rpc_error(-26,
                                 "non-final",
                                 self.nodes[0].sendrawtransaction,
                                 timelock_tx)
 
         self.log.info("Broadcast and mine spend_2 and spend_3")
         wallet.sendrawtransaction(
             from_node=self.nodes[0],
             tx_hex=spend_2['hex'])
         wallet.sendrawtransaction(
             from_node=self.nodes[0],
             tx_hex=spend_3['hex'])
         self.log.info("Generate a block")
         self.generate(self.nodes[0], 1)
         self.log.info(
             "Check that time-locked transaction is still too immature to spend")
         assert_raises_rpc_error(-26,
                                 'non-final',
                                 self.nodes[0].sendrawtransaction,
                                 timelock_tx)
 
         self.log.info("Create spend_2_1 and spend_3_1")
         spend_2_utxo = wallet.get_utxo(txid=spend_2['txid'])
         spend_2_1 = wallet.create_self_transfer(
             from_node=self.nodes[0], utxo_to_spend=spend_2_utxo)
         spend_3_utxo = wallet.get_utxo(txid=spend_3['txid'])
         spend_3_1 = wallet.create_self_transfer(
             from_node=self.nodes[0], utxo_to_spend=spend_3_utxo)
 
         self.log.info("Broadcast and mine spend_3_1")
         spend_3_1_id = self.nodes[0].sendrawtransaction(spend_3_1['hex'])
         self.log.info("Generate a block")
         last_block = self.generate(self.nodes[0], 1)
         # generate() implicitly syncs blocks, so that peer 1 gets the block
         # before timelock_tx.
         # Otherwise, peer 1 would put the timelock_tx in m_recent_rejects
 
         self.log.info("The time-locked transaction can now be spent")
         timelock_tx_id = self.nodes[0].sendrawtransaction(timelock_tx)
 
         self.log.info("Add spend_1 and spend_2_1 to the mempool")
         spend_1_id = self.nodes[0].sendrawtransaction(spend_1['hex'])
         spend_2_1_id = self.nodes[0].sendrawtransaction(spend_2_1['hex'])
 
         assert_equal(set(self.nodes[0].getrawmempool()), {
                      spend_1_id, spend_2_1_id, timelock_tx_id})
         self.sync_all()
 
         self.log.info("invalidate the last block")
         for node in self.nodes:
             node.invalidateblock(last_block[0])
         self.log.info(
             "The time-locked transaction is now too immature and has been removed from the mempool")
         self.log.info(
             "spend_3_1 has been re-orged out of the chain and is back in the mempool")
         assert_equal(set(self.nodes[0].getrawmempool()), {
                      spend_1_id, spend_2_1_id, spend_3_1_id})
 
         self.log.info(
             "Use invalidateblock to re-org back and make all those coinbase spends immature/invalid")
         b = self.nodes[0].getblockhash(first_block + 100)
         for node in self.nodes:
             node.invalidateblock(b)
 
         self.log.info("Check that the mempool is empty")
         assert_equal(set(self.nodes[0].getrawmempool()), set())
 
 
 if __name__ == '__main__':
     MempoolCoinbaseTest().main()
diff --git a/test/functional/mempool_spend_coinbase.py b/test/functional/mempool_spend_coinbase.py
index 8ecaec1bd..14786a500 100755
--- a/test/functional/mempool_spend_coinbase.py
+++ b/test/functional/mempool_spend_coinbase.py
@@ -1,68 +1,75 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-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.
 """Test spending coinbase transactions.
 
 The coinbase transaction in block N can appear in block
 N+100... so is valid in the mempool when the best block
 height is N+99.
 This test makes sure coinbase spends that will be mature
 in the next block are accepted into the memory pool,
 but less mature coinbase spends are NOT.
 """
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 from test_framework.wallet import MiniWallet
 
 
 class MempoolSpendCoinbaseTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
 
     def run_test(self):
         wallet = MiniWallet(self.nodes[0])
 
         # Invalidate two blocks, so that miniwallet has access to a coin that
         # will mature in the next block
         chain_height = 198
         self.nodes[0].invalidateblock(
             self.nodes[0].getblockhash(
                 chain_height + 1))
         assert_equal(chain_height, self.nodes[0].getblockcount())
+        wallet.rescan_utxos()
 
         # Coinbase at height chain_height-100+1 ok in mempool, should
         # get mined. Coinbase at height chain_height-100+2 is
         # too immature to spend.
-        wallet.scan_blocks(start=chain_height - 100 + 1, num=1)
-        utxo_mature = wallet.get_utxo()
-        wallet.scan_blocks(start=chain_height - 100 + 2, num=1)
-        utxo_immature = wallet.get_utxo()
+        def coinbase_txid(h):
+            return self.nodes[0].getblock(
+                self.nodes[0].getblockhash(h))['tx'][0]
+
+        utxo_mature = wallet.get_utxo(
+            txid=coinbase_txid(
+                chain_height - 100 + 1))
+        utxo_immature = wallet.get_utxo(
+            txid=coinbase_txid(
+                chain_height - 100 + 2))
 
         spend_mature_id = wallet.send_self_transfer(
             from_node=self.nodes[0], utxo_to_spend=utxo_mature)["txid"]
 
         # other coinbase should be too immature to spend
         immature_tx = wallet.create_self_transfer(
             from_node=self.nodes[0],
             utxo_to_spend=utxo_immature,
             mempool_valid=False)
         assert_raises_rpc_error(-26,
                                 "bad-txns-premature-spend-of-coinbase",
                                 lambda: self.nodes[0].sendrawtransaction(immature_tx['hex']))
 
         # mempool should have just the mature one
         assert_equal(self.nodes[0].getrawmempool(), [spend_mature_id])
 
         # mine a block, mature one should get confirmed
         self.generate(self.nodes[0], 1)
         assert_equal(set(self.nodes[0].getrawmempool()), set())
 
         # ... and now previously immature can be spent:
         spend_new_id = self.nodes[0].sendrawtransaction(immature_tx['hex'])
         assert_equal(self.nodes[0].getrawmempool(), [spend_new_id])
 
 
 if __name__ == '__main__':
     MempoolSpendCoinbaseTest().main()
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index 2f4c18d57..24c4b3e6b 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -1,498 +1,498 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-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.
 
 """Test RPCs related to blockchainstate.
 
 Test the following RPCs:
     - getblockchaininfo
     - gettxoutsetinfo
     - getdifficulty
     - getbestblockhash
     - getblockhash
     - getblockheader
     - getchaintxstats
     - getnetworkhashps
     - verifychain
 
 Tests correspond to code in rpc/blockchain.cpp.
 """
 
 import http.client
 import os
 import subprocess
 from decimal import Decimal
 
 from test_framework.address import ADDRESS_ECREG_P2SH_OP_TRUE
 from test_framework.blocktools import (
     TIME_GENESIS_BLOCK,
     create_block,
     create_coinbase,
 )
 from test_framework.messages import CBlockHeader, FromHex, msg_block
 from test_framework.p2p import P2PInterface
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
     assert_greater_than,
     assert_greater_than_or_equal,
     assert_is_hash_string,
     assert_is_hex_string,
     assert_raises,
     assert_raises_rpc_error,
     get_datadir_path,
 )
 from test_framework.wallet import MiniWallet
 
 
 class BlockchainTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 1
         self.supports_cli = False
 
     def run_test(self):
         self.mine_chain()
 
         # Set extra args with pruning after rescan is complete
         self.restart_node(0, extra_args=['-stopatheight=207', '-prune=1'])
 
         self._test_getblockchaininfo()
         self._test_getchaintxstats()
         self._test_gettxoutsetinfo()
         self._test_getblockheader()
         self._test_getdifficulty()
         self._test_getnetworkhashps()
         self._test_stopatheight()
         self._test_waitforblockheight()
         if self.is_wallet_compiled():
             self._test_getblock()
         self._test_getblock_txfee()
         assert self.nodes[0].verifychain(4, 0)
 
     def mine_chain(self):
         self.log.info('Create some old blocks')
         for t in range(TIME_GENESIS_BLOCK,
                        TIME_GENESIS_BLOCK + 200 * 600, 600):
             # ten-minute steps from genesis block time
             self.nodes[0].setmocktime(t)
             self.generatetoaddress(
                 self.nodes[0], 1, ADDRESS_ECREG_P2SH_OP_TRUE)
         assert_equal(self.nodes[0].getblockchaininfo()['blocks'], 200)
 
     def _test_getblockchaininfo(self):
         self.log.info("Test getblockchaininfo")
 
         keys = [
             'bestblockhash',
             'blocks',
             'chain',
             'chainwork',
             'difficulty',
             'headers',
             'initialblockdownload',
             'mediantime',
             'pruned',
             'size_on_disk',
             'softforks',
             'verificationprogress',
             'warnings',
         ]
         res = self.nodes[0].getblockchaininfo()
 
         # result should have these additional pruning keys if manual pruning is
         # enabled
         assert_equal(sorted(res.keys()), sorted(
             ['pruneheight', 'automatic_pruning'] + keys))
 
         # size_on_disk should be > 0
         assert_greater_than(res['size_on_disk'], 0)
 
         assert_equal(res['softforks'], {
             'testdummy': {
                 'type': 'bip9',
                 'bip9': {
                     'status': 'started',
                     'bit': 28,
                     'start_time': 0,
                     # testdummy does not have a timeout so is set to the max
                     # int64 value
                     'timeout': 0x7fffffffffffffff,
                     'since': 144,
                     'statistics': {
                         'period': 144,
                         'threshold': 108,
                         'elapsed': 57,
                         'count': 57,
                         'possible': True,
                     },
                 },
                 'active': False,
             },
         })
 
         # pruneheight should be greater or equal to 0
         assert_greater_than_or_equal(res['pruneheight'], 0)
 
         # check other pruning fields given that prune=1
         assert res['pruned']
         assert not res['automatic_pruning']
 
         self.restart_node(0, ['-stopatheight=207'])
         res = self.nodes[0].getblockchaininfo()
         # should have exact keys
         assert_equal(sorted(res.keys()), keys)
 
         self.restart_node(0, ['-stopatheight=207', '-prune=550'])
         res = self.nodes[0].getblockchaininfo()
         # result should have these additional pruning keys if prune=550
         assert_equal(sorted(res.keys()), sorted(
             ['pruneheight', 'automatic_pruning', 'prune_target_size'] + keys))
 
         # check related fields
         assert res['pruned']
         assert_equal(res['pruneheight'], 0)
         assert res['automatic_pruning']
         assert_equal(res['prune_target_size'], 576716800)
         assert_greater_than(res['size_on_disk'], 0)
 
     def _test_getchaintxstats(self):
         self.log.info("Test getchaintxstats")
 
         # Test `getchaintxstats` invalid extra parameters
         assert_raises_rpc_error(
             -1, 'getchaintxstats', self.nodes[0].getchaintxstats, 0, '', 0)
 
         # Test `getchaintxstats` invalid `nblocks`
         assert_raises_rpc_error(
             -1, "JSON value is not an integer as expected", self.nodes[0].getchaintxstats, '')
         assert_raises_rpc_error(
             -8, "Invalid block count: should be between 0 and the block's height - 1", self.nodes[0].getchaintxstats, -1)
         assert_raises_rpc_error(-8, "Invalid block count: should be between 0 and the block's height - 1", self.nodes[
                                 0].getchaintxstats, self.nodes[0].getblockcount())
 
         # Test `getchaintxstats` invalid `blockhash`
         assert_raises_rpc_error(
             -1, "JSON value is not a string as expected", self.nodes[0].getchaintxstats, blockhash=0)
         assert_raises_rpc_error(-8,
                                 "blockhash must be of length 64 (not 1, for '0')",
                                 self.nodes[0].getchaintxstats,
                                 blockhash='0')
         assert_raises_rpc_error(
             -8,
             "blockhash must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
             self.nodes[0].getchaintxstats,
             blockhash='ZZZ0000000000000000000000000000000000000000000000000000000000000')
         assert_raises_rpc_error(
             -5,
             "Block not found",
             self.nodes[0].getchaintxstats,
             blockhash='0000000000000000000000000000000000000000000000000000000000000000')
         blockhash = self.nodes[0].getblockhash(200)
         self.nodes[0].invalidateblock(blockhash)
         assert_raises_rpc_error(
             -8, "Block is not in main chain", self.nodes[0].getchaintxstats, blockhash=blockhash)
         self.nodes[0].reconsiderblock(blockhash)
 
         chaintxstats = self.nodes[0].getchaintxstats(nblocks=1)
         # 200 txs plus genesis tx
         assert_equal(chaintxstats['txcount'], 201)
         # tx rate should be 1 per 10 minutes, or 1/600
         # we have to round because of binary math
         assert_equal(round(chaintxstats['txrate'] * 600, 10), Decimal(1))
 
         b1_hash = self.nodes[0].getblockhash(1)
         b1 = self.nodes[0].getblock(b1_hash)
         b200_hash = self.nodes[0].getblockhash(200)
         b200 = self.nodes[0].getblock(b200_hash)
         time_diff = b200['mediantime'] - b1['mediantime']
 
         chaintxstats = self.nodes[0].getchaintxstats()
         assert_equal(chaintxstats['time'], b200['time'])
         assert_equal(chaintxstats['txcount'], 201)
         assert_equal(chaintxstats['window_final_block_hash'], b200_hash)
         assert_equal(chaintxstats['window_final_block_height'], 200)
         assert_equal(chaintxstats['window_block_count'], 199)
         assert_equal(chaintxstats['window_tx_count'], 199)
         assert_equal(chaintxstats['window_interval'], time_diff)
         assert_equal(
             round(chaintxstats['txrate'] * time_diff, 10), Decimal(199))
 
         chaintxstats = self.nodes[0].getchaintxstats(blockhash=b1_hash)
         assert_equal(chaintxstats['time'], b1['time'])
         assert_equal(chaintxstats['txcount'], 2)
         assert_equal(chaintxstats['window_final_block_hash'], b1_hash)
         assert_equal(chaintxstats['window_final_block_height'], 1)
         assert_equal(chaintxstats['window_block_count'], 0)
         assert 'window_tx_count' not in chaintxstats
         assert 'window_interval' not in chaintxstats
         assert 'txrate' not in chaintxstats
 
     def _test_gettxoutsetinfo(self):
         node = self.nodes[0]
         res = node.gettxoutsetinfo()
 
         assert_equal(res['total_amount'], Decimal('8725000000.00'))
         assert_equal(res['transactions'], 200)
         assert_equal(res['height'], 200)
         assert_equal(res['txouts'], 200)
         assert_equal(res['bogosize'], 14600),
         assert_equal(res['bestblock'], node.getblockhash(200))
         size = res['disk_size']
         assert size > 6400
         assert size < 64000
         assert_equal(len(res['bestblock']), 64)
         assert_equal(len(res['hash_serialized']), 64)
 
         self.log.info(
             "Test that gettxoutsetinfo() works for blockchain with just the genesis block")
         b1hash = node.getblockhash(1)
         node.invalidateblock(b1hash)
 
         res2 = node.gettxoutsetinfo()
         assert_equal(res2['transactions'], 0)
         assert_equal(res2['total_amount'], Decimal('0'))
         assert_equal(res2['height'], 0)
         assert_equal(res2['txouts'], 0)
         assert_equal(res2['bogosize'], 0),
         assert_equal(res2['bestblock'], node.getblockhash(0))
         assert_equal(len(res2['hash_serialized']), 64)
 
         self.log.info(
             "Test that gettxoutsetinfo() returns the same result after invalidate/reconsider block")
         node.reconsiderblock(b1hash)
 
         res3 = node.gettxoutsetinfo()
         # The field 'disk_size' is non-deterministic and can thus not be
         # compared between res and res3.  Everything else should be the same.
         del res['disk_size'], res3['disk_size']
         assert_equal(res, res3)
 
         self.log.info("Test hash_type option for gettxoutsetinfo()")
         # Adding hash_type 'hash_serialized', which is the default, should
         # not change the result.
         res4 = node.gettxoutsetinfo(hash_type='hash_serialized')
         del res4['disk_size']
         assert_equal(res, res4)
 
         # hash_type none should not return a UTXO set hash.
         res5 = node.gettxoutsetinfo(hash_type='none')
         assert 'hash_serialized' not in res5
 
         # hash_type muhash should return a different UTXO set hash.
         res6 = node.gettxoutsetinfo(hash_type='muhash')
         assert 'muhash' in res6
         assert res['hash_serialized'] != res6['muhash']
 
         # muhash should not be returned unless requested.
         for r in [res, res2, res3, res4, res5]:
             assert 'muhash' not in r
 
         # Unknown hash_type raises an error
         assert_raises_rpc_error(-8,
                                 "foohash is not a valid hash_type",
                                 node.gettxoutsetinfo,
                                 "foohash")
 
     def _test_getblockheader(self):
         node = self.nodes[0]
 
         assert_raises_rpc_error(-8,
                                 "hash must be of length 64 (not 8, for 'nonsense')",
                                 node.getblockheader,
                                 "nonsense")
         assert_raises_rpc_error(
             -8,
             "hash must be hexadecimal string (not 'ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844')",
             node.getblockheader,
             "ZZZ7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")
         assert_raises_rpc_error(-5, "Block not found", node.getblockheader,
                                 "0cf7bb8b1697ea987f3b223ba7819250cae33efacb068d23dc24859824a77844")
 
         besthash = node.getbestblockhash()
         secondbesthash = node.getblockhash(199)
         header = node.getblockheader(blockhash=besthash)
 
         assert_equal(header['hash'], besthash)
         assert_equal(header['height'], 200)
         assert_equal(header['confirmations'], 1)
         assert_equal(header['previousblockhash'], secondbesthash)
         assert_is_hex_string(header['chainwork'])
         assert_equal(header['nTx'], 1)
         assert_is_hash_string(header['hash'])
         assert_is_hash_string(header['previousblockhash'])
         assert_is_hash_string(header['merkleroot'])
         assert_is_hash_string(header['bits'], length=None)
         assert isinstance(header['time'], int)
         assert isinstance(header['mediantime'], int)
         assert isinstance(header['nonce'], int)
         assert isinstance(header['version'], int)
         assert isinstance(int(header['versionHex'], 16), int)
         assert isinstance(header['difficulty'], Decimal)
 
         # Test with verbose=False, which should return the header as hex.
         header_hex = node.getblockheader(blockhash=besthash, verbose=False)
         assert_is_hex_string(header_hex)
 
         header = FromHex(CBlockHeader(), header_hex)
         header.calc_sha256()
         assert_equal(header.hash, besthash)
 
         assert 'previousblockhash' not in node.getblockheader(
             node.getblockhash(0))
         assert 'nextblockhash' not in node.getblockheader(
             node.getbestblockhash())
 
     def _test_getdifficulty(self):
         difficulty = self.nodes[0].getdifficulty()
         # 1 hash in 2 should be valid, so difficulty should be 1/2**31
         # binary => decimal => binary math is why we do this check
         assert abs(difficulty * 2**31 - 1) < 0.0001
 
     def _test_getnetworkhashps(self):
         hashes_per_second = self.nodes[0].getnetworkhashps()
         # This should be 2 hashes every 10 minutes or 1/300
         assert abs(hashes_per_second * 300 - 1) < 0.0001
 
     def _test_stopatheight(self):
         assert_equal(self.nodes[0].getblockcount(), 200)
         self.generatetoaddress(self.nodes[0], 6, ADDRESS_ECREG_P2SH_OP_TRUE)
         assert_equal(self.nodes[0].getblockcount(), 206)
         self.log.debug('Node should not stop at this height')
         assert_raises(subprocess.TimeoutExpired,
                       lambda: self.nodes[0].process.wait(timeout=3))
         try:
             self.generatetoaddress(
                 self.nodes[0], 1, ADDRESS_ECREG_P2SH_OP_TRUE, sync_fun=self.no_op)
         except (ConnectionError, http.client.BadStatusLine):
             pass  # The node already shut down before response
         self.log.debug('Node should stop at this height...')
         self.nodes[0].wait_until_stopped()
         self.start_node(0)
         assert_equal(self.nodes[0].getblockcount(), 207)
 
     def _test_waitforblockheight(self):
         self.log.info("Test waitforblockheight")
         node = self.nodes[0]
         peer = node.add_p2p_connection(P2PInterface())
 
         current_height = node.getblock(node.getbestblockhash())['height']
 
         # Create a fork somewhere below our current height, invalidate the tip
         # of that fork, and then ensure that waitforblockheight still
         # works as expected.
         #
         # (Previously this was broken based on setting
         # `rpc/blockchain.cpp:latestblock` incorrectly.)
         #
         b20hash = node.getblockhash(20)
         b20 = node.getblock(b20hash)
 
         def solve_and_send_block(prevhash, height, time):
             b = create_block(prevhash, create_coinbase(height), time)
             b.solve()
             peer.send_and_ping(msg_block(b))
             return b
 
         b21f = solve_and_send_block(int(b20hash, 16), 21, b20['time'] + 1)
         b22f = solve_and_send_block(b21f.sha256, 22, b21f.nTime + 1)
 
         node.invalidateblock(b22f.hash)
 
         def assert_waitforheight(height, timeout=2):
             assert_equal(
                 node.waitforblockheight(
                     height=height, timeout=timeout)['height'],
                 current_height)
 
         assert_waitforheight(0)
         assert_waitforheight(current_height - 1)
         assert_waitforheight(current_height)
         assert_waitforheight(current_height + 1)
 
     def _test_getblock(self):
         # Checks for getblock verbose outputs
         node = self.nodes[0]
 
         blockcount = node.getblockcount()
         blockhash = node.getblockhash(blockcount - 1)
         nextblockhash = node.getblockhash(blockcount)
 
         blockinfo = node.getblock(blockhash, 2)
         blockheaderinfo = node.getblockheader(blockhash, True)
 
         assert_equal(blockinfo['hash'], blockhash)
         assert_equal(blockinfo['confirmations'], 2)
         assert_equal(blockinfo['height'], blockheaderinfo['height'])
         assert_equal(blockinfo['versionHex'], blockheaderinfo['versionHex'])
         assert_equal(blockinfo['version'], blockheaderinfo['version'])
         assert_equal(blockinfo['size'], 181)
         assert_equal(blockinfo['merkleroot'], blockheaderinfo['merkleroot'])
         # Verify transaction data by check the hex values
         for tx in blockinfo['tx']:
             rawtransaction = node.getrawtransaction(
                 txid=tx['txid'], verbose=True, blockhash=blockhash)
             assert_equal(tx['hex'], rawtransaction['hex'])
         assert_equal(blockinfo['time'], blockheaderinfo['time'])
         assert_equal(blockinfo['mediantime'], blockheaderinfo['mediantime'])
         assert_equal(blockinfo['nonce'], blockheaderinfo['nonce'])
         assert_equal(blockinfo['bits'], blockheaderinfo['bits'])
         assert_equal(blockinfo['difficulty'], blockheaderinfo['difficulty'])
         assert_equal(blockinfo['chainwork'], blockheaderinfo['chainwork'])
         assert_equal(
             blockinfo['previousblockhash'],
             blockheaderinfo['previousblockhash'])
         assert_equal(blockinfo['nextblockhash'], nextblockhash)
         assert_equal(
             blockinfo['nextblockhash'],
             blockheaderinfo['nextblockhash'])
 
         assert 'previousblockhash' not in node.getblock(node.getblockhash(0))
         assert 'nextblockhash' not in node.getblock(node.getbestblockhash())
 
     def _test_getblock_txfee(self):
         node = self.nodes[0]
 
         miniwallet = MiniWallet(node)
-        miniwallet.scan_blocks(num=5)
+        miniwallet.rescan_utxos()
 
         fee_per_byte = Decimal('0.1')
         fee_per_kb = 1000 * fee_per_byte
 
         miniwallet.send_self_transfer(fee_rate=fee_per_kb, from_node=node)
         blockhash = self.generate(node, 1)[0]
 
         self.log.info(
             "Test that getblock with verbosity only includes the txid")
         block = node.getblock(blockhash, 1)
         assert_equal(block['tx'][1], miniwallet.get_utxo()['txid'])
 
         self.log.info(
             'Test that getblock with verbosity 2 includes expected fee')
         block = node.getblock(blockhash, 2)
         tx = block['tx'][1]
         assert_equal(tx['fee'], tx['size'] * fee_per_byte)
 
         self.log.info(
             "Test that getblock with verbosity 2 still works with pruned Undo data")
         datadir = get_datadir_path(self.options.tmpdir, 0)
 
         def move_block_file(old, new):
             old_path = os.path.join(datadir, self.chain, 'blocks', old)
             new_path = os.path.join(datadir, self.chain, 'blocks', new)
             os.rename(old_path, new_path)
 
         # Move instead of deleting so we can restore chain state afterwards
         move_block_file('rev00000.dat', 'rev_wrong')
 
         block = node.getblock(blockhash, 2)
         assert 'fee' not in block['tx'][1]
 
         # Restore chain state
         move_block_file('rev_wrong', 'rev00000.dat')
 
 
 if __name__ == '__main__':
     BlockchainTest().main()
diff --git a/test/functional/test_framework/wallet.py b/test/functional/test_framework/wallet.py
index a46eb9e51..9c1b47144 100644
--- a/test/functional/test_framework/wallet.py
+++ b/test/functional/test_framework/wallet.py
@@ -1,218 +1,210 @@
 #!/usr/bin/env python3
 # Copyright (c) 2020 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """A limited-functionality wallet, which may replace a real wallet in tests"""
 
 from copy import deepcopy
 from decimal import Decimal
 from typing import Optional
 
 from test_framework.address import (
     ADDRESS_ECREG_P2SH_OP_TRUE,
     SCRIPTSIG_OP_TRUE,
 )
 from test_framework.messages import (
     XEC,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     FromHex,
     ToHex,
 )
 from test_framework.txtools import pad_tx
 from test_framework.util import (
     assert_equal,
     assert_greater_than_or_equal,
     satoshi_round,
 )
 
 DEFAULT_FEE = Decimal("100.00")
 
 
 class MiniWallet:
     def __init__(self, test_node):
         self._test_node = test_node
         self._utxos = []
         self._address = ADDRESS_ECREG_P2SH_OP_TRUE
         self._scriptPubKey = bytes.fromhex(
             self._test_node.validateaddress(
                 self._address)['scriptPubKey'])
 
     def rescan_utxos(self):
         """Drop all utxos and rescan the utxo set"""
         self._utxos = []
         res = self._test_node.scantxoutset(
             action="start", scanobjects=[f'raw({self._scriptPubKey.hex()})'])
         assert_equal(True, res['success'])
         for utxo in res['unspents']:
             self._utxos.append(
                 {'txid': utxo['txid'], 'vout': utxo['vout'], 'value': utxo['amount']})
 
-    def scan_blocks(self, *, start=1, num):
-        """Scan the blocks for self._address outputs and add them to self._utxos"""
-        for i in range(start, start + num):
-            block = self._test_node.getblock(
-                blockhash=self._test_node.getblockhash(i), verbosity=2)
-            for tx in block['tx']:
-                self.scan_tx(tx)
-
     def scan_tx(self, tx):
         """Scan the tx for self._scriptPubKey outputs and add them to self._utxos"""
         for out in tx['vout']:
             if out['scriptPubKey']['hex'] == self._scriptPubKey.hex():
                 self._utxos.append(
                     {'txid': tx['txid'], 'vout': out['n'], 'value': out['value']})
 
     def generate(self, num_blocks, **kwargs):
         """Generate blocks with coinbase outputs to the internal address,
         and append the outputs to the internal list"""
         blocks = self._test_node.generatetodescriptor(
             num_blocks, f'raw({self._scriptPubKey.hex()})', **kwargs)
         for b in blocks:
             cb_tx = self._test_node.getblock(blockhash=b, verbosity=2)['tx'][0]
             self._utxos.append(
                 {'txid': cb_tx['txid'], 'vout': 0, 'value': cb_tx['vout'][0]['value']})
         return blocks
 
     def get_utxo(self, *, txid: Optional[str] = ''):
         """
         Returns a utxo and marks it as spent (pops it from the internal list)
 
         Args:
         txid: get the first utxo we find from a specific transaction
 
         Note: Can be used to get the change output immediately after a send_self_transfer
         """
         # by default the last utxo
         index = -1
         if txid:
             utxo = next(filter(lambda utxo: txid == utxo['txid'], self._utxos))
             index = self._utxos.index(utxo)
         return self._utxos.pop(index)
 
     def send_self_transfer(self, **kwargs):
         """Create and send a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed."""
         tx = self.create_self_transfer(**kwargs)
         self.sendrawtransaction(
             from_node=kwargs['from_node'],
             tx_hex=tx['hex'])
         return tx
 
     def create_self_transfer(self, *, fee_rate=Decimal("3000.00"),
                              from_node, utxo_to_spend=None, mempool_valid=True, locktime=0):
         """Create and return a tx with the specified fee_rate. Fee may be exact or at most one satoshi higher than needed."""
         self._utxos = sorted(self._utxos, key=lambda k: k['value'])
         # Pick the largest utxo (if none provided) and hope it covers the fee
         utxo_to_spend = utxo_to_spend or self._utxos.pop()
 
         # The size will be enforced by pad_tx()
         size = 100
         send_value = satoshi_round(
             utxo_to_spend['value'] - fee_rate * (Decimal(size) / 1000))
         fee = utxo_to_spend['value'] - send_value
         assert send_value > 0
 
         tx = CTransaction()
         tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16),
                                   utxo_to_spend['vout']))]
         tx.vout = [CTxOut(int(send_value * XEC), self._scriptPubKey)]
         tx.nLockTime = locktime
         tx.vin[0].scriptSig = SCRIPTSIG_OP_TRUE
         pad_tx(tx, size)
         tx_hex = tx.serialize().hex()
         tx_info = from_node.testmempoolaccept([tx_hex])[0]
         assert_equal(mempool_valid, tx_info['allowed'])
         if mempool_valid:
             assert_equal(tx_info['size'], size)
             assert_equal(tx_info['fees']['base'], fee)
         return {'txid': tx_info['txid'], 'hex': tx_hex, 'tx': tx}
 
     def sendrawtransaction(self, *, from_node, tx_hex):
         from_node.sendrawtransaction(tx_hex)
         self.scan_tx(from_node.decoderawtransaction(tx_hex))
 
 
 def make_chain(node, address, privkeys, parent_txid, parent_value, n=0,
                parent_locking_script=None, fee=DEFAULT_FEE):
     """Build a transaction that spends parent_txid.vout[n] and produces one
     output with amount = parent_value with a fee deducted.
     Return tuple (CTransaction object, raw hex, nValue, scriptPubKey of the
     output created).
     """
     inputs = [{"txid": parent_txid, "vout": n}]
     my_value = parent_value - fee
     outputs = {address: my_value}
     rawtx = node.createrawtransaction(inputs, outputs)
     prevtxs = [{
         "txid": parent_txid,
         "vout": n,
         "scriptPubKey": parent_locking_script,
         "amount": parent_value,
     }] if parent_locking_script else None
     signedtx = node.signrawtransactionwithkey(
         hexstring=rawtx, privkeys=privkeys, prevtxs=prevtxs)
     assert signedtx["complete"]
     tx = FromHex(CTransaction(), signedtx["hex"])
     return (tx, signedtx["hex"], my_value, tx.vout[0].scriptPubKey.hex())
 
 
 def create_child_with_parents(node, address, privkeys, parents_tx, values,
                               locking_scripts, fee=DEFAULT_FEE):
     """Creates a transaction that spends the first output of each parent in parents_tx."""
     num_parents = len(parents_tx)
     total_value = sum(values)
     inputs = [{"txid": tx.get_id(), "vout": 0} for tx in parents_tx]
     outputs = {address: total_value - fee}
     rawtx_child = node.createrawtransaction(inputs, outputs)
     prevtxs = []
     for i in range(num_parents):
         prevtxs.append(
             {"txid": parents_tx[i].get_id(), "vout": 0,
              "scriptPubKey": locking_scripts[i], "amount": values[i]})
     signedtx_child = node.signrawtransactionwithkey(
         hexstring=rawtx_child, privkeys=privkeys, prevtxs=prevtxs)
     assert signedtx_child["complete"]
     return signedtx_child["hex"]
 
 
 def create_raw_chain(node, first_coin, address, privkeys, chain_length=50):
     """Helper function: create a "chain" of chain_length transactions.
     The nth transaction in the chain is a child of the n-1th transaction and
     parent of the n+1th transaction.
     """
     parent_locking_script = None
     txid = first_coin["txid"]
     chain_hex = []
     chain_txns = []
     value = first_coin["amount"]
 
     for _ in range(chain_length):
         (tx, txhex, value, parent_locking_script) = make_chain(
             node, address, privkeys, txid, value, 0, parent_locking_script)
         txid = tx.get_id()
         chain_hex.append(txhex)
         chain_txns.append(tx)
 
     return (chain_hex, chain_txns)
 
 
 def bulk_transaction(
         tx: CTransaction, node, target_size: int, privkeys=None, prevtxs=None
 ) -> CTransaction:
     """Return a padded and signed transaction. The original transaction is left
     unaltered.
     If privkeys is not specified, it is assumed that the transaction has an
     anyone-can-spend output as unique output.
     """
     tx_heavy = deepcopy(tx)
     pad_tx(tx_heavy, target_size)
     assert_greater_than_or_equal(tx_heavy.billable_size(), target_size)
     if privkeys is not None:
         signed_tx = node.signrawtransactionwithkey(
             ToHex(tx_heavy), privkeys, prevtxs)
         return FromHex(CTransaction(), signed_tx["hex"])
     # OP_TRUE
     tx_heavy.vin[0].scriptSig = SCRIPTSIG_OP_TRUE
     return tx_heavy