diff --git a/test/functional/abc-magnetic-anomaly-mining.py b/test/functional/abc-magnetic-anomaly-mining.py
--- a/test/functional/abc-magnetic-anomaly-mining.py
+++ b/test/functional/abc-magnetic-anomaly-mining.py
@@ -87,7 +87,7 @@
             outputs[addr] -= fee
 
             rawtx = mining_node.createrawtransaction(inputs, outputs)
-            signedtx = mining_node.signrawtransaction(rawtx)
+            signedtx = mining_node.signrawtransactionwithwallet(rawtx)
             txid = mining_node.sendrawtransaction(signedtx['hex'])
             # number of outputs is the same as the number of sigops in this
             # case
diff --git a/test/functional/feature_bip68_sequence.py b/test/functional/feature_bip68_sequence.py
--- a/test/functional/feature_bip68_sequence.py
+++ b/test/functional/feature_bip68_sequence.py
@@ -107,7 +107,8 @@
         tx1.vout = [CTxOut(value, CScript([b'a']))]
         pad_tx(tx1)
 
-        tx1_signed = self.nodes[0].signrawtransaction(ToHex(tx1))["hex"]
+        tx1_signed = self.nodes[0].signrawtransactionwithwallet(ToHex(tx1))[
+            "hex"]
         tx1_id = self.nodes[0].sendrawtransaction(tx1_signed)
         tx1_id = int(tx1_id, 16)
 
@@ -229,7 +230,8 @@
             tx_size = len(ToHex(tx)) // 2 + 120 * num_inputs + 50
             tx.vout.append(
                 CTxOut(int(value - self.relayfee * tx_size * COIN / 1000), CScript([b'a'])))
-            rawtx = self.nodes[0].signrawtransaction(ToHex(tx))["hex"]
+            rawtx = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))[
+                "hex"]
 
             if (using_sequence_locks and not should_pass):
                 # This transaction should be rejected
@@ -269,7 +271,7 @@
             CTxOut(int(0), CScript([b'a']))]
         tx2.vout[0].nValue = tx1.vout[0].nValue - \
             fee_multiplier * self.nodes[0].calculate_fee(tx2)
-        tx2_raw = self.nodes[0].signrawtransaction(ToHex(tx2))["hex"]
+        tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         tx2.rehash()
         self.nodes[0].sendrawtransaction(tx2_raw)
@@ -355,7 +357,7 @@
         tx5.vin.append(
             CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
         tx5.vout[0].nValue += int(utxos[0]["amount"] * COIN)
-        raw_tx5 = self.nodes[0].signrawtransaction(ToHex(tx5))["hex"]
+        raw_tx5 = self.nodes[0].signrawtransactionwithwallet(ToHex(tx5))["hex"]
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR,
                                 self.nodes[0].sendrawtransaction, raw_tx5)
@@ -426,7 +428,7 @@
             CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), CScript([b'a']))]
 
         # sign tx2
-        tx2_raw = self.nodes[0].signrawtransaction(ToHex(tx2))["hex"]
+        tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         pad_tx(tx2)
         tx2.rehash()
@@ -486,7 +488,8 @@
         rawtxfund = self.nodes[1].fundrawtransaction(rawtx)['hex']
         tx = FromHex(CTransaction(), rawtxfund)
         tx.nVersion = 2
-        tx_signed = self.nodes[1].signrawtransaction(ToHex(tx))["hex"]
+        tx_signed = self.nodes[1].signrawtransactionwithwallet(ToHex(tx))[
+            "hex"]
         try:
             self.nodes[1].sendrawtransaction(tx_signed)
             assert(before_activation == False)
diff --git a/test/functional/feature_cltv.py b/test/functional/feature_cltv.py
--- a/test/functional/feature_cltv.py
+++ b/test/functional/feature_cltv.py
@@ -62,7 +62,7 @@
         [height_op, OP_CHECKLOCKTIMEVERIFY, OP_DROP, OP_TRUE])
     tx.rehash()
 
-    signed_result = node.signrawtransaction(ToHex(tx))
+    signed_result = node.signrawtransactionwithwallet(ToHex(tx))
 
     new_tx = FromHex(CTransaction(), signed_result['hex'])
     pad_tx(new_tx)
@@ -76,7 +76,7 @@
     inputs = [{"txid": from_txid, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
-    signresult = node.signrawtransaction(rawtx)
+    signresult = node.signrawtransactionwithwallet(rawtx)
     tx = FromHex(CTransaction(), signresult['hex'])
     return tx
 
@@ -174,7 +174,8 @@
         output = {self.nodeaddress: 49.98}
 
         rejectedtx_raw = self.nodes[0].createrawtransaction(inputs, output)
-        rejectedtx_signed = self.nodes[0].signrawtransaction(rejectedtx_raw)
+        rejectedtx_signed = self.nodes[0].signrawtransactionwithwallet(
+            rejectedtx_raw)
 
         # Couldn't complete signature due to CLTV
         assert(rejectedtx_signed['errors'][0]['error'] == 'Negative locktime')
diff --git a/test/functional/feature_csv_activation.py b/test/functional/feature_csv_activation.py
--- a/test/functional/feature_csv_activation.py
+++ b/test/functional/feature_csv_activation.py
@@ -134,7 +134,7 @@
 
     def sign_transaction(self, node, unsignedtx):
         rawtx = ToHex(unsignedtx)
-        signresult = node.signrawtransaction(rawtx)
+        signresult = node.signrawtransactionwithwallet(rawtx)
         tx = FromHex(CTransaction(), signresult['hex'])
         return tx
 
diff --git a/test/functional/feature_dbcrash.py b/test/functional/feature_dbcrash.py
--- a/test/functional/feature_dbcrash.py
+++ b/test/functional/feature_dbcrash.py
@@ -229,7 +229,7 @@
                     CTxOut(output_amount, hex_str_to_bytes(utxo['scriptPubKey'])))
 
             # Sign and send the transaction to get into the mempool
-            tx_signed_hex = node.signrawtransaction(ToHex(tx))['hex']
+            tx_signed_hex = node.signrawtransactionwithwallet(ToHex(tx))['hex']
             node.sendrawtransaction(tx_signed_hex)
             num_transactions += 1
 
diff --git a/test/functional/feature_dersig.py b/test/functional/feature_dersig.py
--- a/test/functional/feature_dersig.py
+++ b/test/functional/feature_dersig.py
@@ -49,7 +49,7 @@
     inputs = [{"txid": from_txid, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
-    signresult = node.signrawtransaction(rawtx)
+    signresult = node.signrawtransactionwithwallet(rawtx)
     return FromHex(CTransaction(), signresult['hex'])
 
 
diff --git a/test/functional/feature_nulldummy.py b/test/functional/feature_nulldummy.py
--- a/test/functional/feature_nulldummy.py
+++ b/test/functional/feature_nulldummy.py
@@ -90,7 +90,7 @@
         inputs = [{"txid": txid, "vout": 0}]
         outputs = {to_address: amount}
         rawtx = node.createrawtransaction(inputs, outputs)
-        signresult = node.signrawtransaction(rawtx)
+        signresult = node.signrawtransactionwithwallet(rawtx)
         return FromHex(CTransaction(), signresult['hex'])
 
     def block_submit(self, node, txs, accept=False):
diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
--- a/test/functional/mempool_limit.py
+++ b/test/functional/mempool_limit.py
@@ -36,7 +36,7 @@
         txF = self.nodes[0].fundrawtransaction(tx)
         # return to automatic fee selection
         self.nodes[0].settxfee(0)
-        txFS = self.nodes[0].signrawtransaction(txF['hex'])
+        txFS = self.nodes[0].signrawtransactionwithwallet(txF['hex'])
         txid = self.nodes[0].sendrawtransaction(txFS['hex'])
 
         for i in range(utxo_groups):
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -35,7 +35,7 @@
         for i in range(num_outputs):
             outputs[node.getnewaddress()] = send_value
         rawtx = node.createrawtransaction(inputs, outputs)
-        signedtx = node.signrawtransaction(rawtx)
+        signedtx = node.signrawtransactionwithwallet(rawtx)
         txid = node.sendrawtransaction(signedtx['hex'])
         fulltx = node.getrawtransaction(txid, 1)
         # make sure we didn't generate a change output
@@ -230,7 +230,7 @@
         for i in range(2):
             outputs[self.nodes[0].getnewaddress()] = send_value
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-        signedtx = self.nodes[0].signrawtransaction(rawtx)
+        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         txid = self.nodes[0].sendrawtransaction(signedtx['hex'])
         tx0_id = txid
         value = send_value
@@ -256,7 +256,7 @@
         inputs = [{'txid': tx1_id, 'vout': 0}, {'txid': txid, 'vout': 0}]
         outputs = {self.nodes[0].getnewaddress(): send_value + value - 4 * fee}
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-        signedtx = self.nodes[0].signrawtransaction(rawtx)
+        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         txid = self.nodes[0].sendrawtransaction(signedtx['hex'])
         sync_mempools(self.nodes)
 
diff --git a/test/functional/mempool_reorg.py b/test/functional/mempool_reorg.py
--- a/test/functional/mempool_reorg.py
+++ b/test/functional/mempool_reorg.py
@@ -55,7 +55,8 @@
         timelock_tx = timelock_tx.replace("ffffffff", "11111191", 1)
         timelock_tx = timelock_tx[:-8] + \
             hex(self.nodes[0].getblockcount() + 2)[2:] + "000000"
-        timelock_tx = self.nodes[0].signrawtransaction(timelock_tx)["hex"]
+        timelock_tx = self.nodes[0].signrawtransactionwithwallet(timelock_tx)[
+            "hex"]
         # This will raise an exception because the timelock transaction is too immature to spend
         assert_raises_rpc_error(-26, "bad-txns-nonfinal",
                                 self.nodes[0].sendrawtransaction, timelock_tx)
diff --git a/test/functional/mining_prioritisetransaction.py b/test/functional/mining_prioritisetransaction.py
--- a/test/functional/mining_prioritisetransaction.py
+++ b/test/functional/mining_prioritisetransaction.py
@@ -122,7 +122,7 @@
         inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
         outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee
         raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
-        tx_hex = self.nodes[0].signrawtransaction(raw_tx)["hex"]
+        tx_hex = self.nodes[0].signrawtransactionwithwallet(raw_tx)["hex"]
         txid = self.nodes[0].sendrawtransaction(tx_hex)
 
         # A tx that spends an in-mempool tx has 0 priority, so we can use it to
@@ -133,7 +133,7 @@
         outputs = {}
         outputs[self.nodes[0].getnewaddress()] = utxo["amount"] - self.relayfee
         raw_tx2 = self.nodes[0].createrawtransaction(inputs, outputs)
-        tx2_hex = self.nodes[0].signrawtransaction(raw_tx2)["hex"]
+        tx2_hex = self.nodes[0].signrawtransactionwithwallet(raw_tx2)["hex"]
         tx2_id = self.nodes[0].decoderawtransaction(tx2_hex)["txid"]
 
         # This will raise an exception due to min relay fee not being met
diff --git a/test/functional/rpc_fundrawtransaction.py b/test/functional/rpc_fundrawtransaction.py
--- a/test/functional/rpc_fundrawtransaction.py
+++ b/test/functional/rpc_fundrawtransaction.py
@@ -460,7 +460,7 @@
         rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
         fundedTx = self.nodes[2].fundrawtransaction(rawTx)
 
-        signedTx = self.nodes[2].signrawtransaction(fundedTx['hex'])
+        signedTx = self.nodes[2].signrawtransactionwithwallet(fundedTx['hex'])
         txId = self.nodes[2].sendrawtransaction(signedTx['hex'])
         self.sync_all()
         self.nodes[1].generate(1)
@@ -518,7 +518,7 @@
 
         # now we need to unlock
         self.nodes[1].walletpassphrase("test", 600)
-        signedTx = self.nodes[1].signrawtransaction(fundedTx['hex'])
+        signedTx = self.nodes[1].signrawtransactionwithwallet(fundedTx['hex'])
         txId = self.nodes[1].sendrawtransaction(signedTx['hex'])
         self.nodes[1].generate(1)
         self.sync_all()
@@ -582,7 +582,8 @@
             self.nodes[0].getnewaddress(): 0.15, self.nodes[0].getnewaddress(): 0.04}
         rawTx = self.nodes[1].createrawtransaction(inputs, outputs)
         fundedTx = self.nodes[1].fundrawtransaction(rawTx)
-        fundedAndSignedTx = self.nodes[1].signrawtransaction(fundedTx['hex'])
+        fundedAndSignedTx = self.nodes[1].signrawtransactionwithwallet(
+            fundedTx['hex'])
         txId = self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
         self.sync_all()
         self.nodes[0].generate(1)
@@ -643,9 +644,9 @@
         assert_equal(result["fee"] + res_dec["vout"][
                      result["changepos"]]["value"], watchonly_amount / 10)
 
-        signedtx = self.nodes[3].signrawtransaction(result["hex"])
+        signedtx = self.nodes[3].signrawtransactionwithwallet(result["hex"])
         assert(not signedtx["complete"])
-        signedtx = self.nodes[0].signrawtransaction(signedtx["hex"])
+        signedtx = self.nodes[0].signrawtransactionwithwallet(signedtx["hex"])
         assert(signedtx["complete"])
         self.nodes[0].sendrawtransaction(signedtx["hex"])
         self.nodes[0].generate(1)
diff --git a/test/functional/rpc_rawtransaction.py b/test/functional/rpc_rawtransaction.py
--- a/test/functional/rpc_rawtransaction.py
+++ b/test/functional/rpc_rawtransaction.py
@@ -6,7 +6,7 @@
 
 # Tests the following RPCs:
 #    - createrawtransaction
-#    - signrawtransaction
+#    - signrawtransactionwithwallet
 #    - sendrawtransaction
 #    - decoderawtransaction
 #    - getrawtransaction
@@ -56,7 +56,7 @@
         outputs = {self.nodes[0].getnewaddress(): 4.998}
         rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
         rawtx = pad_raw_tx(rawtx)
-        rawtx = self.nodes[2].signrawtransaction(rawtx)
+        rawtx = self.nodes[2].signrawtransactionwithwallet(rawtx)
 
         # This will raise an exception since there are missing inputs
         assert_raises_rpc_error(
@@ -132,11 +132,12 @@
         }]
         outputs = {self.nodes[0].getnewaddress(): 2.19}
         rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
-        rawTxPartialSigned = self.nodes[1].signrawtransaction(rawTx, inputs)
+        rawTxPartialSigned = self.nodes[1].signrawtransactionwithwallet(
+            rawTx, inputs)
         # node1 only has one key, can't comp. sign the tx
         assert_equal(rawTxPartialSigned['complete'], False)
 
-        rawTxSigned = self.nodes[2].signrawtransaction(rawTx, inputs)
+        rawTxSigned = self.nodes[2].signrawtransactionwithwallet(rawTx, inputs)
         # node2 can sign the tx compl., own two of three keys
         assert_equal(rawTxSigned['complete'], True)
         self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
@@ -186,12 +187,14 @@
                    ['hex'], "redeemScript": mSigObjValid['hex'], "amount": vout['value']}]
         outputs = {self.nodes[0].getnewaddress(): 2.19}
         rawTx2 = self.nodes[2].createrawtransaction(inputs, outputs)
-        rawTxPartialSigned1 = self.nodes[1].signrawtransaction(rawTx2, inputs)
+        rawTxPartialSigned1 = self.nodes[1].signrawtransactionwithwallet(
+            rawTx2, inputs)
         self.log.info(rawTxPartialSigned1)
         # node1 only has one key, can't comp. sign the tx
         assert_equal(rawTxPartialSigned['complete'], False)
 
-        rawTxPartialSigned2 = self.nodes[2].signrawtransaction(rawTx2, inputs)
+        rawTxPartialSigned2 = self.nodes[2].signrawtransactionwithwallet(
+            rawTx2, inputs)
         self.log.info(rawTxPartialSigned2)
         # node2 only has one key, can't comp. sign the tx
         assert_equal(rawTxPartialSigned2['complete'], False)
diff --git a/test/functional/rpc_signrawtransaction.py b/test/functional/rpc_signrawtransaction.py
--- a/test/functional/rpc_signrawtransaction.py
+++ b/test/functional/rpc_signrawtransaction.py
@@ -2,7 +2,7 @@
 # Copyright (c) 2015-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 transaction signing using the signrawtransactionwithwallet RPC."""
+"""Test transaction signing using the signrawtransaction* RPCs."""
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
@@ -40,12 +40,16 @@
             rawTx, privKeys, inputs)
 
         # 1) The transaction has a complete set of signatures
-        assert 'complete' in rawTxSigned
-        assert_equal(rawTxSigned['complete'], True)
+        assert rawTxSigned['complete']
 
         # 2) No script verification error occurred
         assert 'errors' not in rawTxSigned
 
+        # Perform the same test on signrawtransaction
+        rawTxSigned2 = self.nodes[0].signrawtransaction(
+            rawTx, inputs, privKeys)
+        assert_equal(rawTxSigned, rawTxSigned2)
+
     def script_verification_error_test(self):
         """Creates and signs a raw transaction with valid (vin 0), invalid (vin 1) and one missing (vin 2) input script.
 
@@ -98,8 +102,7 @@
             rawTx, privKeys, scripts)
 
         # 3) The transaction has no complete set of signatures
-        assert 'complete' in rawTxSigned
-        assert_equal(rawTxSigned['complete'], False)
+        assert not rawTxSigned['complete']
 
         # 4) Two script verification errors occurred
         assert 'errors' in rawTxSigned
@@ -119,6 +122,11 @@
         assert_equal(rawTxSigned['errors'][1]['txid'], inputs[2]['txid'])
         assert_equal(rawTxSigned['errors'][1]['vout'], inputs[2]['vout'])
 
+        # Perform same test with signrawtransaction
+        rawTxSigned2 = self.nodes[0].signrawtransaction(
+            rawTx, scripts, privKeys)
+        assert_equal(rawTxSigned, rawTxSigned2)
+
     def test_sighashes(self):
         """Creates and signs a raw transaction with various sighashes.
 
@@ -166,8 +174,8 @@
 
         # 1) If the sighash is valid with FORKID, the signature is complete
         for sighash in valid_sighashes:
-            rawTxSigned = self.nodes[0].signrawtransaction(rawTx, inputs,
-                                                           privKeys, sighash)
+            rawTxSigned = self.nodes[0].signrawtransactionwithkey(
+                rawTx, privKeys, inputs, sighash)
             assert 'complete' in rawTxSigned
             assert_equal(rawTxSigned['complete'], True)
             assert 'errors' not in rawTxSigned
@@ -175,14 +183,14 @@
         # 2) If FORKID is missing in the sighash, the RPC throws an error
         for sighash in no_forkid_sighashes:
             assert_raises_rpc_error(-8, "Signature must use SIGHASH_FORKID",
-                                    self.nodes[0].signrawtransaction,
-                                        rawTx, inputs, privKeys, sighash)
+                                    self.nodes[0].signrawtransactionwithkey,
+                                    rawTx, privKeys, inputs, sighash)
 
         # 3) If the sighash is invalid the RPC throws an error
         for sighash in invalid_sighashes:
             assert_raises_rpc_error(-8, "Invalid sighash param",
-                                    self.nodes[0].signrawtransaction,
-                                        rawTx, inputs, privKeys, sighash)
+                                    self.nodes[0].signrawtransactionwithkey,
+                                    rawTx, privKeys, inputs, sighash)
 
     def run_test(self):
         self.successful_signing_test()
diff --git a/test/functional/rpc_txoutproof.py b/test/functional/rpc_txoutproof.py
--- a/test/functional/rpc_txoutproof.py
+++ b/test/functional/rpc_txoutproof.py
@@ -44,11 +44,11 @@
         tx1 = self.nodes[0].createrawtransaction(
             [node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
         txid1 = self.nodes[0].sendrawtransaction(
-            self.nodes[0].signrawtransaction(tx1)["hex"])
+            self.nodes[0].signrawtransactionwithwallet(tx1)["hex"])
         tx2 = self.nodes[0].createrawtransaction(
             [node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
         txid2 = self.nodes[0].sendrawtransaction(
-            self.nodes[0].signrawtransaction(tx2)["hex"])
+            self.nodes[0].signrawtransactionwithwallet(tx2)["hex"])
         # This will raise an exception because the transaction is not yet in a block
         assert_raises_rpc_error(-5, "Transaction not yet in block",
                                 self.nodes[0].gettxoutproof, [txid1])
@@ -73,7 +73,7 @@
         tx3 = self.nodes[1].createrawtransaction(
             [txin_spent], {self.nodes[0].getnewaddress(): 49.98})
         txid3 = self.nodes[0].sendrawtransaction(
-            self.nodes[1].signrawtransaction(tx3)["hex"])
+            self.nodes[1].signrawtransactionwithwallet(tx3)["hex"])
         self.nodes[0].generate(1)
         self.sync_all()
 
diff --git a/test/functional/test_framework/blocktools.py b/test/functional/test_framework/blocktools.py
--- a/test/functional/test_framework/blocktools.py
+++ b/test/functional/test_framework/blocktools.py
@@ -153,7 +153,7 @@
         # Due to possible truncation, we go ahead and take another satoshi in
         # fees to ensure the transaction gets through
         ctx.vout[1].nValue -= fee + 1
-        signed_tx = node.signrawtransaction(ToHex(ctx))["hex"]
+        signed_tx = node.signrawtransactionwithwallet(ToHex(ctx))["hex"]
         node.sendrawtransaction(signed_tx)
 
     while (node.getmempoolinfo()['size'] > 0):
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -534,7 +534,7 @@
     outputs[self_address] = float(amount + fee)
 
     self_rawtx = from_node.createrawtransaction(inputs, outputs)
-    self_signresult = from_node.signrawtransaction(self_rawtx)
+    self_signresult = from_node.signrawtransactionwithwallet(self_rawtx)
     self_txid = from_node.sendrawtransaction(self_signresult["hex"], True)
 
     vout = find_output(from_node, self_txid, amount + fee)
@@ -544,7 +544,7 @@
     outputs = {to_node.getnewaddress(): float(amount)}
 
     rawtx = from_node.createrawtransaction(inputs, outputs)
-    signresult = from_node.signrawtransaction(rawtx)
+    signresult = from_node.signrawtransactionwithwallet(rawtx)
     txid = from_node.sendrawtransaction(signresult["hex"], True)
 
     return (txid, signresult["hex"])
@@ -609,7 +609,7 @@
     inputs = [{"txid": coinbase, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
-    signresult = node.signrawtransaction(rawtx)
+    signresult = node.signrawtransactionwithwallet(rawtx)
     assert_equal(signresult["complete"], True)
     return signresult["hex"]
 
diff --git a/test/functional/wallet_abandonconflict.py b/test/functional/wallet_abandonconflict.py
--- a/test/functional/wallet_abandonconflict.py
+++ b/test/functional/wallet_abandonconflict.py
@@ -76,7 +76,7 @@
 
         outputs[self.nodes[0].getnewaddress()] = Decimal("14.99998")
         outputs[self.nodes[1].getnewaddress()] = Decimal("5")
-        signed = self.nodes[0].signrawtransaction(
+        signed = self.nodes[0].signrawtransactionwithwallet(
             self.nodes[0].createrawtransaction(inputs, outputs))
         txAB1 = self.nodes[0].sendrawtransaction(signed["hex"])
 
@@ -92,7 +92,7 @@
         inputs.append({"txid": txC, "vout": nC})
         outputs = {}
         outputs[self.nodes[0].getnewaddress()] = Decimal("24.9996")
-        signed2 = self.nodes[0].signrawtransaction(
+        signed2 = self.nodes[0].signrawtransactionwithwallet(
             self.nodes[0].createrawtransaction(inputs, outputs))
         txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"])
 
@@ -100,7 +100,7 @@
         signed3_change = Decimal("24.999")
         inputs = [{"txid": txABC2, "vout": 0}]
         outputs = {self.nodes[0].getnewaddress(): signed3_change}
-        signed3 = self.nodes[0].signrawtransaction(
+        signed3 = self.nodes[0].signrawtransactionwithwallet(
             self.nodes[0].createrawtransaction(inputs, outputs))
         # note tx is never directly referenced, only abandoned as a child of the above
         self.nodes[0].sendrawtransaction(signed3["hex"])
@@ -181,7 +181,7 @@
         outputs = {}
         outputs[self.nodes[1].getnewaddress()] = Decimal("9.9999")
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
-        signed = self.nodes[0].signrawtransaction(tx)
+        signed = self.nodes[0].signrawtransactionwithwallet(tx)
         self.nodes[1].sendrawtransaction(signed["hex"])
         self.nodes[1].generate(1)
 
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -151,7 +151,8 @@
             inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
             outputs[self.nodes[2].getnewaddress("from1")] = utxo["amount"] - 3
             raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
-            txns_to_send.append(self.nodes[0].signrawtransaction(raw_tx))
+            txns_to_send.append(
+                self.nodes[0].signrawtransactionwithwallet(raw_tx))
 
         # Have node 1 (miner) send the transactions
         self.nodes[1].sendrawtransaction(txns_to_send[0]["hex"], True)
@@ -242,7 +243,7 @@
         rawTx = self.nodes[1].createrawtransaction(inputs, outputs).replace(
             "c0833842", "00000000")  # replace 11.11 with 0.0 (int32)
         decRawTx = self.nodes[1].decoderawtransaction(rawTx)
-        signedRawTx = self.nodes[1].signrawtransaction(rawTx)
+        signedRawTx = self.nodes[1].signrawtransactionwithwallet(rawTx)
         decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex'])
         zeroValueTxid = decRawTx['txid']
         self.nodes[1].sendrawtransaction(signedRawTx['hex'])
@@ -430,7 +431,7 @@
         # Split into two chains
         rawtx = self.nodes[0].createrawtransaction([{"txid": singletxid, "vout": 0}], {
                                                    chain_addrs[0]: node0_balance / 2 - Decimal('0.01'), chain_addrs[1]: node0_balance / 2 - Decimal('0.01')})
-        signedtx = self.nodes[0].signrawtransaction(rawtx)
+        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         singletxid = self.nodes[0].sendrawtransaction(signedtx["hex"])
         self.nodes[0].generate(1)
 
diff --git a/test/functional/wallet_txn_doublespend.py b/test/functional/wallet_txn_doublespend.py
--- a/test/functional/wallet_txn_doublespend.py
+++ b/test/functional/wallet_txn_doublespend.py
@@ -68,7 +68,7 @@
         outputs[node1_address] = 1240
         outputs[change_address] = 1248 - 1240 + doublespend_fee
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-        doublespend = self.nodes[0].signrawtransaction(rawtx)
+        doublespend = self.nodes[0].signrawtransactionwithwallet(rawtx)
         assert_equal(doublespend["complete"], True)
 
         # Create two spends using 1 50 BTC coin each