diff --git a/test/functional/wallet_import_rescan.py b/test/functional/wallet_import_rescan.py
--- a/test/functional/wallet_import_rescan.py
+++ b/test/functional/wallet_import_rescan.py
@@ -69,11 +69,12 @@
             }], {"rescan": self.rescan in (Rescan.yes, Rescan.late_timestamp)})
             assert_equal(response, [{"success": True}])
 
-    def check(self, txid=None, amount=None, confirmations=None):
+    def check(self, txid=None, amount=None, confirmation_height=None):
         """Verify that listtransactions/listreceivedbyaddress return expected values."""
 
         txs = self.node.listtransactions(
             label=self.label, count=10000, include_watchonly=True)
+        current_height = self.node.getblockcount()
         assert_equal(len(txs), self.expected_txs)
 
         addresses = self.node.listreceivedbyaddress(
@@ -89,13 +90,15 @@
             assert_equal(tx["category"], "receive")
             assert_equal(tx["label"], self.label)
             assert_equal(tx["txid"], txid)
-            assert_equal(tx["confirmations"], confirmations)
+            assert_equal(tx["confirmations"],
+                         1 + current_height - confirmation_height)
             assert_equal("trusted" not in tx, True)
 
             address, = [ad for ad in addresses if txid in ad["txids"]]
             assert_equal(address["address"], self.address["address"])
             assert_equal(address["amount"], self.expected_balance)
-            assert_equal(address["confirmations"], confirmations)
+            assert_equal(address["confirmations"],
+                         1 + current_height - confirmation_height)
             # Verify the transaction is correctly marked watchonly depending on
             # whether the transaction pays to an imported public key or
             # imported private key. The test setup ensures that transaction
@@ -164,14 +167,16 @@
             variant.initial_amount = 1 - (i + 1) / 64
             variant.initial_txid = self.nodes[0].sendtoaddress(
                 variant.address["address"], variant.initial_amount)
+            # Generate one block for each send
+            self.nodes[0].generate(1)
+            variant.confirmation_height = self.nodes[0].getblockcount()
+            variant.timestamp = self.nodes[0].getblockheader(
+                self.nodes[0].getbestblockhash())["time"]
 
-        # Generate a block containing the initial transactions, then another
-        # block further in the future (past the rescan window).
-        self.nodes[0].generate(1)
+        # Generate a block further in the future (past the rescan window).
         assert_equal(self.nodes[0].getrawmempool(), [])
-        timestamp = self.nodes[0].getblockheader(
-            self.nodes[0].getbestblockhash())["time"]
-        set_node_times(self.nodes, timestamp + TIMESTAMP_WINDOW + 1)
+        set_node_times(self.nodes, self.nodes[0].getblockheader(
+            self.nodes[0].getbestblockhash())["time"] + TIMESTAMP_WINDOW + 1)
         self.nodes[0].generate(1)
         self.sync_all()
 
@@ -182,11 +187,12 @@
             expect_rescan = variant.rescan == Rescan.yes
             variant.node = self.nodes[2 + IMPORT_NODES.index(
                 ImportNode(variant.prune, expect_rescan))]
-            variant.do_import(timestamp)
+            variant.do_import(variant.timestamp)
             if expect_rescan:
                 variant.expected_balance = variant.initial_amount
                 variant.expected_txs = 1
-                variant.check(variant.initial_txid, variant.initial_amount, 2)
+                variant.check(variant.initial_txid, variant.initial_amount,
+                              variant.confirmation_height)
             else:
                 variant.expected_balance = 0
                 variant.expected_txs = 0
@@ -197,9 +203,10 @@
             variant.sent_amount = 1 - (2 * i + 1) / 128
             variant.sent_txid = self.nodes[0].sendtoaddress(
                 variant.address["address"], variant.sent_amount)
+            # Generate one block for each send
+            self.nodes[0].generate(1)
+            variant.confirmation_height = self.nodes[0].getblockcount()
 
-        # Generate a block containing the new transactions.
-        self.nodes[0].generate(1)
         assert_equal(self.nodes[0].getrawmempool(), [])
         self.sync_all()
 
@@ -208,7 +215,8 @@
             self.log.info('Run check for variant {}'.format(variant))
             variant.expected_balance += variant.sent_amount
             variant.expected_txs += 1
-            variant.check(variant.sent_txid, variant.sent_amount, 1)
+            variant.check(variant.sent_txid, variant.sent_amount,
+                          variant.confirmation_height)
 
 
 if __name__ == "__main__":