diff --git a/test/functional/abc-finalize-block.py b/test/functional/abc-finalize-block.py
--- a/test/functional/abc-finalize-block.py
+++ b/test/functional/abc-finalize-block.py
@@ -9,6 +9,7 @@
 from test_framework.util import assert_equal, assert_raises_rpc_error, connect_nodes_bi, sync_blocks, wait_until
 
 RPC_FINALIZE_INVALID_BLOCK_ERROR = 'finalize-invalid-block'
+RPC_FORK_PRIOR_FINALIZED_ERROR = 'bad-fork-prior-finalized'
 RPC_BLOCK_NOT_FOUND_ERROR = 'Block not found'
 AUTO_FINALIZATION_DEPTH = 10
 
@@ -37,13 +38,14 @@
         tip = node.getbestblockhash()
         node.finalizeblock(tip)
         assert_equal(node.getbestblockhash(), tip)
+        assert_equal(node.getfinalizedblockhash(), tip)
 
         alt_node = self.nodes[1]
         connect_nodes_bi(self.nodes, 0, 1)
         sync_blocks(self.nodes[0:2])
 
         alt_node.invalidateblock(tip)
-        # We will use this later to check auto-finalization during a reorg
+        # We will use this later
         fork_block = alt_node.getbestblockhash()
 
         # Node 0 should not accept the whole alt_node's chain due to tip being finalized,
@@ -78,7 +80,6 @@
 
         # First block header is accepted as valid-header
         alt_node.generate(1)
-        alt_210 = alt_node.getbestblockhash()
         wait_for_block(node, alt_node.getbestblockhash(), "valid-headers")
 
         # Second block header is accepted but set invalid
@@ -92,6 +93,9 @@
             assert_raises_rpc_error(-5, RPC_BLOCK_NOT_FOUND_ERROR,
                                     node.getblockheader, alt_node.getbestblockhash())
 
+        assert_equal(node.getbestblockhash(), tip)
+        assert_equal(node.getfinalizedblockhash(), tip)
+
         self.log.info("Test that an invalid block cannot be finalized...")
         assert_raises_rpc_error(-20, RPC_FINALIZE_INVALID_BLOCK_ERROR,
                                 node.finalizeblock, invalid_block)
@@ -139,8 +143,13 @@
         # (200)->(201)-> // ->(209 finalized)->(210)
         node.reconsiderblock(invalid_block)
 
-        alt_node.generate(1)
-        sync_blocks(self.nodes[0:2])
+        def wait_for_tip(node, tip):
+            def check_tip():
+                return node.getbestblockhash() == tip
+            wait_until(check_tip)
+
+        alt_node_tip = alt_node.generate(1)[-1]
+        wait_for_tip(node, alt_node_tip)
 
         assert_equal(node.getbestblockhash(), alt_node.getbestblockhash())
         assert_equal(node.getfinalizedblockhash(), fork_block)
@@ -166,28 +175,57 @@
         self.log.info("Try to finalize a block on a competiting fork...")
         assert_raises_rpc_error(-20, RPC_FINALIZE_INVALID_BLOCK_ERROR,
                                 node.finalizeblock, alt_node.getbestblockhash())
-        assert node.getfinalizedblockhash() != alt_node.getbestblockhash(), \
-            "Finalized block should not be alt_node's tip!"
         assert_equal(node.getfinalizedblockhash(), tip)
 
+        self.log.info(
+            "Check auto-finalization occurs as the tip move forward...")
+        # Reconsider alt_node tip then generate some more blocks on alt_node.
+        # Auto-finalization will occur on both chains.
+        #
+        # Expected state:
+        #
+        # On alt_node:
+        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
+        #                          /
+        # (200)->(201)-> // ->(209)->(210 invalid)
+        #
+        # On node:
+        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
+        #                          /
+        # (200)->(201)-> // ->(209)->(210 invalid)
+        node.reconsiderblock(alt_node.getbestblockhash())
+        alt_node_new_tip = alt_node.generate(10)[-1]
+        wait_for_tip(node, alt_node_new_tip)
+
+        assert_equal(node.getbestblockhash(), alt_node.getbestblockhash())
+        assert_equal(node.getfinalizedblockhash(), alt_node_tip)
+        assert_equal(alt_node.getfinalizedblockhash(), alt_node_tip)
+
+        self.log.info(
+            "Try to finalize a block on an already finalized chain...")
+        # Finalizing a block of an already finalized chain should have no effect
+        block_218 = node.getblockheader(alt_node_tip)['previousblockhash']
+        node.finalizeblock(block_218)
+        assert_equal(node.getfinalizedblockhash(), alt_node_tip)
+
         self.log.info(
             "Make sure reconsidering block move the finalization point...")
-        # Reconsidering alt_node tip will move finalized block on node
+        # Reconsidering the tip will move back the finalized block on node
         #
         # Expected state:
         #
         # On alt_node:
-        #                                          >(210)->(211)-> // ->(218)->(219 tip)
-        #                                         /
-        # (200)->(201)-> // ->(209 auto-finalized)->(210 invalid)
+        #                           >(210)->(211)-> // ->(219 auto-finalized)-> // ->(229 tip)
+        #                          /
+        # (200)->(201)-> // ->(209)->(210 invalid)
         #
         # On node:
-        #                                     >(210)-> // ->(219 tip)
+        #                                     >(210)->(211)-> // ->(219)-> // ->(229 tip)
         #                                    /
         # (200)->(201)-> // ->(209 finalized)->(210)
-        node.reconsiderblock(alt_node.getbestblockhash())
+        node.reconsiderblock(tip)
 
-        assert_equal(node.getbestblockhash(), alt_node.getbestblockhash())
+        assert_equal(node.getbestblockhash(), alt_node_new_tip)
         assert_equal(node.getfinalizedblockhash(), fork_block)