diff --git a/src/script/script_error.cpp b/src/script/script_error.cpp
index b4762bac8..f6b1e3c42 100644
--- a/src/script/script_error.cpp
+++ b/src/script/script_error.cpp
@@ -1,115 +1,115 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-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 <script/script_error.h>
 
 #include <string>
 
 std::string ScriptErrorString(const ScriptError serror) {
     switch (serror) {
         case ScriptError::OK:
             return "No error";
         case ScriptError::EVAL_FALSE:
             return "Script evaluated without error but finished with a "
                    "false/empty top stack element";
         case ScriptError::VERIFY:
             return "Script failed an OP_VERIFY operation";
         case ScriptError::EQUALVERIFY:
             return "Script failed an OP_EQUALVERIFY operation";
         case ScriptError::CHECKMULTISIGVERIFY:
             return "Script failed an OP_CHECKMULTISIGVERIFY operation";
         case ScriptError::CHECKSIGVERIFY:
             return "Script failed an OP_CHECKSIGVERIFY operation";
         case ScriptError::CHECKDATASIGVERIFY:
             return "Script failed an OP_CHECKDATASIGVERIFY operation";
         case ScriptError::NUMEQUALVERIFY:
             return "Script failed an OP_NUMEQUALVERIFY operation";
         case ScriptError::SCRIPT_SIZE:
             return "Script is too big";
         case ScriptError::PUSH_SIZE:
             return "Push value size limit exceeded";
         case ScriptError::OP_COUNT:
             return "Operation limit exceeded";
         case ScriptError::STACK_SIZE:
             return "Stack size limit exceeded";
         case ScriptError::SIG_COUNT:
             return "Signature count negative or greater than pubkey count";
         case ScriptError::PUBKEY_COUNT:
             return "Pubkey count negative or limit exceeded";
         case ScriptError::INPUT_SIGCHECKS:
             return "Input SigChecks limit exceeded";
         case ScriptError::INVALID_OPERAND_SIZE:
             return "Invalid operand size";
         case ScriptError::INVALID_NUMBER_RANGE:
             return "Given operand is not a number within the valid range "
                    "[-2^31...2^31]";
         case ScriptError::IMPOSSIBLE_ENCODING:
             return "The requested encoding is impossible to satisfy";
         case ScriptError::INVALID_SPLIT_RANGE:
             return "Invalid OP_SPLIT range";
         case ScriptError::INVALID_BIT_COUNT:
             return "Invalid number of bit set in OP_CHECKMULTISIG";
         case ScriptError::BAD_OPCODE:
             return "Opcode missing or not understood";
         case ScriptError::DISABLED_OPCODE:
             return "Attempted to use a disabled opcode";
         case ScriptError::INVALID_STACK_OPERATION:
             return "Operation not valid with the current stack size";
         case ScriptError::INVALID_ALTSTACK_OPERATION:
             return "Operation not valid with the current altstack size";
         case ScriptError::OP_RETURN:
             return "OP_RETURN was encountered";
         case ScriptError::UNBALANCED_CONDITIONAL:
             return "Invalid OP_IF construction";
         case ScriptError::DIV_BY_ZERO:
             return "Division by zero error";
         case ScriptError::MOD_BY_ZERO:
             return "Modulo by zero error";
         case ScriptError::INVALID_BITFIELD_SIZE:
             return "Bitfield of unexpected size error";
         case ScriptError::INVALID_BIT_RANGE:
             return "Bitfield's bit out of the expected range";
         case ScriptError::NEGATIVE_LOCKTIME:
             return "Negative locktime";
         case ScriptError::UNSATISFIED_LOCKTIME:
             return "Locktime requirement not satisfied";
         case ScriptError::SIG_HASHTYPE:
             return "Signature hash type missing or not understood";
         case ScriptError::SIG_DER:
             return "Non-canonical DER signature";
         case ScriptError::MINIMALDATA:
             return "Data push larger than necessary";
         case ScriptError::SIG_PUSHONLY:
             return "Only push operators allowed in signatures";
         case ScriptError::SIG_HIGH_S:
             return "Non-canonical signature: S value is unnecessarily high";
         case ScriptError::MINIMALIF:
             return "OP_IF/NOTIF argument must be minimal";
         case ScriptError::SIG_NULLFAIL:
             return "Signature must be zero for failed CHECK(MULTI)SIG "
                    "operation";
         case ScriptError::SIG_BADLENGTH:
             return "Signature cannot be 65 bytes in CHECKMULTISIG";
         case ScriptError::SIG_NONSCHNORR:
             return "Only Schnorr signatures allowed in this operation";
         case ScriptError::DISCOURAGE_UPGRADABLE_NOPS:
             return "NOPx reserved for soft-fork upgrades";
         case ScriptError::PUBKEYTYPE:
             return "Public key is neither compressed or uncompressed";
         case ScriptError::CLEANSTACK:
-            return "Extra items left on stack after execution";
+            return "Stack size must be exactly one after execution";
         case ScriptError::ILLEGAL_FORKID:
             return "Illegal use of SIGHASH_FORKID";
         case ScriptError::MUST_USE_FORKID:
             return "Signature must use SIGHASH_FORKID";
         case ScriptError::SIGCHECKS_LIMIT_EXCEEDED:
             return "Validation resources exceeded (SigChecks)";
         case ScriptError::UNKNOWN:
         case ScriptError::ERROR_COUNT:
         default:
             break;
     }
     return "unknown error";
 }
diff --git a/test/functional/abc-segwit-recovery.py b/test/functional/abc-segwit-recovery.py
index 4360db6d8..36f1d65f1 100755
--- a/test/functional/abc-segwit-recovery.py
+++ b/test/functional/abc-segwit-recovery.py
@@ -1,228 +1,228 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """
 This test checks that blocks containing segwit recovery transactions will be accepted,
 that segwit recovery transactions are rejected from mempool acceptance (even with
 -acceptnonstdtxn=1), and that segwit recovery transactions don't result in bans.
 """
 
 import time
 from typing import Optional, Sequence
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     make_conform_to_ctor,
 )
 from test_framework.messages import (
     COIN,
     CBlock,
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     ToHex,
 )
 from test_framework.p2p import P2PDataStore
 from test_framework.script import (
     OP_EQUAL,
     OP_HASH160,
     OP_TRUE,
     CScript,
     hash160,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_raises_rpc_error
 
 TEST_TIME = int(time.time())
 
 # Error due to non clean stack
-CLEANSTACK_ERROR = 'non-mandatory-script-verify-flag (Extra items left on stack after execution)'
+CLEANSTACK_ERROR = 'non-mandatory-script-verify-flag (Stack size must be exactly one after execution)'
 RPC_CLEANSTACK_ERROR = CLEANSTACK_ERROR
 EVAL_FALSE_ERROR = 'non-mandatory-script-verify-flag (Script evaluated without error but finished with a false/empty top stack elem'
 RPC_EVAL_FALSE_ERROR = EVAL_FALSE_ERROR + "ent)"
 
 
 class PreviousSpendableOutput(object):
 
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
         self.n = n
 
 
 class SegwitRecoveryTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
         self.tip_height = 0
         # We have 2 nodes:
         # 1) node_nonstd (nodes[0]) accepts non-standard txns. It does not
         #    accept Segwit recovery transactions, since it is included in
         #    standard flags, and transactions that violate these flags are
         #    never accepted into the mempool.
         # 2) node_std (nodes[1]) doesn't accept non-standard txns and
         #    doesn't have us whitelisted. It's used to test for bans, as we
         #    connect directly to it via mininode and send a segwit spending
         #    txn. This transaction is non-standard. We check that sending
         #    this transaction doesn't result in a ban.
         # Nodes are connected to each other, so node_std receives blocks and
         # transactions that node_nonstd has accepted. Since we are checking
         # that segwit spending txn are not resulting in bans, node_nonstd
         # doesn't get banned when forwarding this kind of transactions to
         # node_std.
         self.extra_args = [['-whitelist=noban@127.0.0.1',
                             "-acceptnonstdtxn"],
                            ["-acceptnonstdtxn=0"]]
 
     def make_block(self, base_block: Optional[CBlock]) -> CBlock:
         """
         Build a new block and return it.
         Increment the tip_height counter.
 
         If base_block is None, use the genesis block as base block.
         """
         if base_block is None:
             base_block_hash = self.genesis_hash
             block_time = TEST_TIME
         else:
             base_block_hash = base_block.sha256
             block_time = base_block.nTime + 1
         # First create the coinbase
         self.tip_height += 1
         coinbase = create_coinbase(self.tip_height)
         coinbase.rehash()
         block = create_block(base_block_hash, coinbase, block_time)
 
         # Do PoW, which is cheap on regnet
         block.solve()
         return block
 
     def run_test(self):
         self.genesis_hash = int(self.nodes[0].getbestblockhash(), 16)
         spendable_outputs = []
 
         # shorthand
         node_nonstd = self.nodes[0]
         node_std = self.nodes[1]
 
         peer_nonstd = node_nonstd.add_p2p_connection(P2PDataStore())
         peer_std = node_std.add_p2p_connection(P2PDataStore())
 
         # adds transactions to the block and updates state
         def update_block(block: CBlock,
                          new_transactions: Sequence[CTransaction]):
             block.vtx.extend(new_transactions)
             make_conform_to_ctor(block)
             block.hashMerkleRoot = block.calc_merkle_root()
             block.solve()
 
         # Returns 2 transactions:
         # 1) txfund: create outputs in segwit addresses
         # 2) txspend: spends outputs from segwit addresses
         def create_segwit_fund_and_spend_tx(spend, case0=False):
             if not case0:
                 # Spending from a P2SH-P2WPKH coin,
                 #   txhash:a45698363249312f8d3d93676aa714be59b0bd758e62fa054fb1ea6218480691
                 redeem_script0 = bytearray.fromhex(
                     '0014fcf9969ce1c98a135ed293719721fb69f0b686cb')
                 # Spending from a P2SH-P2WSH coin,
                 #   txhash:6b536caf727ccd02c395a1d00b752098ec96e8ec46c96bee8582be6b5060fa2f
                 redeem_script1 = bytearray.fromhex(
                     '0020fc8b08ed636cb23afcb425ff260b3abd03380a2333b54cfa5d51ac52d803baf4')
             else:
                 redeem_script0 = bytearray.fromhex('51020000')
                 redeem_script1 = bytearray.fromhex('53020080')
             redeem_scripts = [redeem_script0, redeem_script1]
 
             # Fund transaction to segwit addresses
             txfund = CTransaction()
             txfund.vin = [CTxIn(COutPoint(spend.tx.sha256, spend.n))]
             amount = (50 * COIN - 1000) // len(redeem_scripts)
             for redeem_script in redeem_scripts:
                 txfund.vout.append(
                     CTxOut(amount, CScript([OP_HASH160, hash160(redeem_script), OP_EQUAL])))
             txfund.rehash()
 
             # Segwit spending transaction
             # We'll test if a node that checks for standardness accepts this
             # txn. It should fail exclusively because of the restriction in
             # the scriptSig (non clean stack..), so all other characteristcs
             # must pass standardness checks. For this reason, we create
             # standard P2SH outputs.
             txspend = CTransaction()
             for i in range(len(redeem_scripts)):
                 txspend.vin.append(
                     CTxIn(COutPoint(txfund.sha256, i), CScript([redeem_scripts[i]])))
             txspend.vout = [CTxOut(50 * COIN - 2000,
                                    CScript([OP_HASH160, hash160(CScript([OP_TRUE])), OP_EQUAL]))]
             txspend.rehash()
 
             return txfund, txspend
 
         # Create a new block
         block = self.make_block(base_block=None)
         spendable_outputs.append(block)
         peer_nonstd.send_blocks_and_test([block], node_nonstd)
 
         # Now we need that block to mature so we can spend the coinbase.
         matureblocks = []
         for _ in range(199):
             block = self.make_block(block)
             matureblocks.append(block)
             spendable_outputs.append(block)
         peer_nonstd.send_blocks_and_test(matureblocks, node_nonstd)
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
         for _ in range(100):
             out.append(
                 PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0))
 
         # Create segwit funding and spending transactions
         txfund, txspend = create_segwit_fund_and_spend_tx(out[0])
         txfund_case0, txspend_case0 = create_segwit_fund_and_spend_tx(
             out[1], True)
 
         # Mine txfund, as it can't go into node_std mempool because it's
         # nonstandard.
         block = self.make_block(block)
         update_block(block, [txfund, txfund_case0])
         peer_nonstd.send_blocks_and_test([block], node_nonstd)
 
         # Check both nodes are synchronized before continuing.
         self.sync_blocks()
 
         # Check that upgraded nodes checking for standardness are not banning
         # nodes sending segwit spending txns.
         peer_nonstd.send_txs_and_test([txspend], node_nonstd, success=False,
                                       reject_reason=CLEANSTACK_ERROR)
         peer_nonstd.send_txs_and_test([txspend_case0], node_nonstd, success=False,
                                       reject_reason=EVAL_FALSE_ERROR)
         peer_std.send_txs_and_test([txspend], node_std, success=False,
                                    reject_reason=CLEANSTACK_ERROR)
         peer_std.send_txs_and_test([txspend_case0], node_std, success=False,
                                    reject_reason=EVAL_FALSE_ERROR)
 
         # Segwit recovery txns are never accepted into the mempool,
         # as they are included in standard flags.
         assert_raises_rpc_error(-26, RPC_CLEANSTACK_ERROR,
                                 node_nonstd.sendrawtransaction, ToHex(txspend))
         assert_raises_rpc_error(-26, RPC_EVAL_FALSE_ERROR,
                                 node_nonstd.sendrawtransaction, ToHex(txspend_case0))
         assert_raises_rpc_error(-26, RPC_CLEANSTACK_ERROR,
                                 node_std.sendrawtransaction, ToHex(txspend))
         assert_raises_rpc_error(-26, RPC_EVAL_FALSE_ERROR,
                                 node_std.sendrawtransaction, ToHex(txspend_case0))
 
         # Blocks containing segwit spending txns are accepted in both nodes.
         block = self.make_block(block)
         update_block(block, [txspend, txspend_case0])
         peer_nonstd.send_blocks_and_test([block], node_nonstd)
         self.sync_blocks()
 
 
 if __name__ == '__main__':
     SegwitRecoveryTest().main()