diff --git a/src/test/prevector_tests.cpp b/src/test/prevector_tests.cpp
index 32c36e707..58edc2608 100644
--- a/src/test/prevector_tests.cpp
+++ b/src/test/prevector_tests.cpp
@@ -1,264 +1,264 @@
 // 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.
 
 #include <prevector.h>
 
 #include <reverse_iterator.h>
 #include <serialize.h>
 #include <streams.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <vector>
 
 BOOST_FIXTURE_TEST_SUITE(prevector_tests, TestingSetup)
 
 template <unsigned int N, typename T> class prevector_tester {
     typedef std::vector<T> realtype;
     realtype real_vector;
     realtype real_vector_alt;
 
     typedef prevector<N, T> pretype;
     pretype pre_vector;
     pretype pre_vector_alt;
 
     typedef typename pretype::size_type Size;
     bool passed = true;
     FastRandomContext rand_cache;
     uint256 rand_seed;
 
     template <typename A, typename B> void local_check_equal(A a, B b) {
         local_check(a == b);
     }
     void local_check(bool b) { passed &= b; }
     void test() {
         const pretype &const_pre_vector = pre_vector;
         local_check_equal(real_vector.size(), pre_vector.size());
         local_check_equal(real_vector.empty(), pre_vector.empty());
         for (Size s = 0; s < real_vector.size(); s++) {
             local_check(real_vector[s] == pre_vector[s]);
             local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
             local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
             local_check(&(pre_vector[s]) ==
                         &*((pre_vector.end() + s) - real_vector.size()));
         }
         // local_check(realtype(pre_vector) == real_vector);
         local_check(pretype(real_vector.begin(), real_vector.end()) ==
                     pre_vector);
         local_check(pretype(pre_vector.begin(), pre_vector.end()) ==
                     pre_vector);
         size_t pos = 0;
         for (const T &v : pre_vector) {
             local_check(v == real_vector[pos++]);
         }
         for (const T &v : reverse_iterate(pre_vector)) {
             local_check(v == real_vector[--pos]);
         }
         for (const T &v : const_pre_vector) {
             local_check(v == real_vector[pos++]);
         }
         for (const T &v : reverse_iterate(const_pre_vector)) {
             local_check(v == real_vector[--pos]);
         }
         CDataStream ss1(SER_DISK, 0);
         CDataStream ss2(SER_DISK, 0);
         ss1 << real_vector;
         ss2 << pre_vector;
         local_check_equal(ss1.size(), ss2.size());
         for (Size s = 0; s < ss1.size(); s++) {
             local_check_equal(ss1[s], ss2[s]);
         }
     }
 
 public:
     void resize(Size s) {
         real_vector.resize(s);
         local_check_equal(real_vector.size(), s);
         pre_vector.resize(s);
         local_check_equal(pre_vector.size(), s);
         test();
     }
 
     void reserve(Size s) {
         real_vector.reserve(s);
         local_check(real_vector.capacity() >= s);
         pre_vector.reserve(s);
         local_check(pre_vector.capacity() >= s);
         test();
     }
 
     void insert(Size position, const T &value) {
         real_vector.insert(real_vector.begin() + position, value);
         pre_vector.insert(pre_vector.begin() + position, value);
         test();
     }
 
     void insert(Size position, Size count, const T &value) {
         real_vector.insert(real_vector.begin() + position, count, value);
         pre_vector.insert(pre_vector.begin() + position, count, value);
         test();
     }
 
     template <typename I> void insert_range(Size position, I first, I last) {
         real_vector.insert(real_vector.begin() + position, first, last);
         pre_vector.insert(pre_vector.begin() + position, first, last);
         test();
     }
 
     void erase(Size position) {
         real_vector.erase(real_vector.begin() + position);
         pre_vector.erase(pre_vector.begin() + position);
         test();
     }
 
     void erase(Size first, Size last) {
         real_vector.erase(real_vector.begin() + first,
                           real_vector.begin() + last);
         pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
         test();
     }
 
     void update(Size pos, const T &value) {
         real_vector[pos] = value;
         pre_vector[pos] = value;
         test();
     }
 
     void push_back(const T &value) {
         real_vector.push_back(value);
         pre_vector.push_back(value);
         test();
     }
 
     void pop_back() {
         real_vector.pop_back();
         pre_vector.pop_back();
         test();
     }
 
     void clear() {
         real_vector.clear();
         pre_vector.clear();
     }
 
     void assign(Size n, const T &value) {
         real_vector.assign(n, value);
         pre_vector.assign(n, value);
     }
 
     Size size() const { return real_vector.size(); }
 
     Size capacity() const { return pre_vector.capacity(); }
 
     void shrink_to_fit() {
         pre_vector.shrink_to_fit();
         test();
     }
 
     void swap() {
         real_vector.swap(real_vector_alt);
         pre_vector.swap(pre_vector_alt);
         test();
     }
 
     void move() {
         real_vector = std::move(real_vector_alt);
         real_vector_alt.clear();
         pre_vector = std::move(pre_vector_alt);
         pre_vector_alt.clear();
     }
 
     void copy() {
         real_vector = real_vector_alt;
         pre_vector = pre_vector_alt;
     }
 
     ~prevector_tester() {
         BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString());
     }
 
     prevector_tester() {
         SeedInsecureRand();
-        rand_seed = insecure_rand_seed;
-        rand_cache = insecure_rand_ctx;
+        rand_seed = InsecureRand256();
+        rand_cache = FastRandomContext(rand_seed);
     }
 };
 
 BOOST_AUTO_TEST_CASE(PrevectorTestInt) {
     for (int j = 0; j < 64; j++) {
         prevector_tester<8, int> test;
         for (int i = 0; i < 2048; i++) {
             if (InsecureRandBits(2) == 0) {
                 test.insert(InsecureRandRange(test.size() + 1),
                             insecure_rand());
             }
             if (test.size() > 0 && InsecureRandBits(2) == 1) {
                 test.erase(InsecureRandRange(test.size()));
             }
             if (InsecureRandBits(3) == 2) {
                 int new_size = std::max(
                     0, std::min(30, int(test.size()) +
                                         int(InsecureRandRange(5)) - 2));
                 test.resize(new_size);
             }
             if (InsecureRandBits(3) == 3) {
                 test.insert(InsecureRandRange(test.size() + 1),
                             1 + InsecureRandBool(), insecure_rand());
             }
             if (InsecureRandBits(3) == 4) {
                 int del = std::min<int>(test.size(), 1 + (InsecureRandBool()));
                 int beg = InsecureRandRange(test.size() + 1 - del);
                 test.erase(beg, beg + del);
             }
             if (InsecureRandBits(4) == 5) {
                 test.push_back(insecure_rand());
             }
             if (test.size() > 0 && InsecureRandBits(4) == 6) {
                 test.pop_back();
             }
             if (InsecureRandBits(5) == 7) {
                 int values[4];
                 int num = 1 + (InsecureRandBits(2));
                 for (int k = 0; k < num; k++) {
                     values[k] = insecure_rand();
                 }
                 test.insert_range(InsecureRandRange(test.size() + 1), values,
                                   values + num);
             }
             if (InsecureRandBits(5) == 8) {
                 int del = std::min<int>(test.size(), 1 + (InsecureRandBits(2)));
                 int beg = InsecureRandRange(test.size() + 1 - del);
                 test.erase(beg, beg + del);
             }
             if (InsecureRandBits(5) == 9) {
                 test.reserve(InsecureRandBits(5));
             }
             if (InsecureRandBits(6) == 10) {
                 test.shrink_to_fit();
             }
             if (test.size() > 0) {
                 test.update(InsecureRandRange(test.size()), insecure_rand());
             }
             if (InsecureRandBits(10) == 11) {
                 test.clear();
             }
             if (InsecureRandBits(9) == 12) {
                 test.assign(InsecureRandBits(5), insecure_rand());
             }
             if (InsecureRandBits(3) == 3) {
                 test.swap();
             }
             if (InsecureRandBits(4) == 8) {
                 test.copy();
             }
             if (InsecureRandBits(5) == 18) {
                 test.move();
             }
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/test_bitcoin.cpp b/src/test/test_bitcoin.cpp
index b94874ac2..c60244922 100644
--- a/src/test/test_bitcoin.cpp
+++ b/src/test/test_bitcoin.cpp
@@ -1,289 +1,288 @@
 // Copyright (c) 2011-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 <test/test_bitcoin.h>
 
 #include <chain.h>
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
 #include <crypto/sha256.h>
 #include <fs.h>
 #include <key.h>
 #include <logging.h>
 #include <miner.h>
 #include <net_processing.h>
 #include <pubkey.h>
 #include <random.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <validation.h>
 
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <cstdio>
 #include <functional>
 #include <list>
 #include <memory>
 #include <thread>
 
 void CConnmanTest::AddNode(CNode &node) {
     LOCK(g_connman->cs_vNodes);
     g_connman->vNodes.push_back(&node);
 }
 
 void CConnmanTest::ClearNodes() {
     LOCK(g_connman->cs_vNodes);
     g_connman->vNodes.clear();
 }
 
-uint256 insecure_rand_seed = GetRandHash();
-FastRandomContext insecure_rand_ctx(insecure_rand_seed);
+FastRandomContext insecure_rand_ctx;
 
 extern void noui_connect();
 
 BasicTestingSetup::BasicTestingSetup(const std::string &chainName) {
     SHA256AutoDetect();
     RandomInit();
     ECC_Start();
     SetupEnvironment();
     SetupNetworking();
     InitSignatureCache();
     InitScriptExecutionCache();
 
     // Don't want to write to debug.log file.
     GetLogger().m_print_to_file = false;
 
     fCheckBlockIndex = true;
     SelectParams(chainName);
     noui_connect();
 
     // Set config parameters to default.
     GlobalConfig config;
     config.SetMaxBlockSize(DEFAULT_MAX_BLOCK_SIZE);
 }
 
 BasicTestingSetup::~BasicTestingSetup() {
     ECC_Stop();
 }
 
 TestingSetup::TestingSetup(const std::string &chainName)
     : BasicTestingSetup(chainName) {
     const Config &config = GetConfig();
     const CChainParams &chainparams = config.GetChainParams();
 
     // Ideally we'd move all the RPC tests to the functional testing framework
     // instead of unit tests, but for now we need these here.
     RPCServer rpcServer;
     RegisterAllRPCCommands(config, rpcServer, tableRPC);
 
     /**
      * RPC does not come out of the warmup state on its own. Normally, this is
      * handled in bitcoind's init path, but unit tests do not trigger this
      * codepath, so we call it explicitly as part of setup.
      */
     std::string rpcWarmupStatus;
     if (RPCIsInWarmup(&rpcWarmupStatus)) {
         SetRPCWarmupFinished();
     }
 
     ClearDatadirCache();
     pathTemp = fs::temp_directory_path() /
                strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(),
                          (int)(InsecureRandRange(100000)));
     fs::create_directories(pathTemp);
     gArgs.ForceSetArg("-datadir", pathTemp.string());
 
     // We have to run a scheduler thread to prevent ActivateBestChain
     // from blocking due to queue overrun.
     threadGroup.create_thread(
         boost::bind(&CScheduler::serviceQueue, &scheduler));
     GetMainSignals().RegisterBackgroundSignalScheduler(scheduler);
 
     g_mempool.setSanityCheck(1.0);
     pblocktree.reset(new CBlockTreeDB(1 << 20, true));
     pcoinsdbview.reset(new CCoinsViewDB(1 << 23, true));
     pcoinsTip.reset(new CCoinsViewCache(pcoinsdbview.get()));
     if (!LoadGenesisBlock(chainparams)) {
         throw std::runtime_error("LoadGenesisBlock failed.");
     }
     {
         CValidationState state;
         if (!ActivateBestChain(config, state)) {
             throw std::runtime_error("ActivateBestChain failed.");
         }
     }
     nScriptCheckThreads = 3;
     for (int i = 0; i < nScriptCheckThreads - 1; i++) {
         threadGroup.create_thread(&ThreadScriptCheck);
     }
 
     // Deterministic randomness for tests.
     g_connman = std::unique_ptr<CConnman>(new CConnman(config, 0x1337, 0x1337));
     connman = g_connman.get();
     peerLogic.reset(new PeerLogicValidation(connman, scheduler));
 }
 
 TestingSetup::~TestingSetup() {
     threadGroup.interrupt_all();
     threadGroup.join_all();
     GetMainSignals().FlushBackgroundCallbacks();
     GetMainSignals().UnregisterBackgroundSignalScheduler();
     g_connman.reset();
     peerLogic.reset();
     UnloadBlockIndex();
     pcoinsTip.reset();
     pcoinsdbview.reset();
     pblocktree.reset();
     fs::remove_all(pathTemp);
 }
 
 TestChain100Setup::TestChain100Setup()
     : TestingSetup(CBaseChainParams::REGTEST) {
     // Generate a 100-block chain:
     coinbaseKey.MakeNewKey(true);
     CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey())
                                      << OP_CHECKSIG;
     for (int i = 0; i < COINBASE_MATURITY; i++) {
         std::vector<CMutableTransaction> noTxns;
         CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
         m_coinbase_txns.push_back(b.vtx[0]);
     }
 }
 
 //
 // Create a new block with just given transactions, coinbase paying to
 // scriptPubKey, and try to add it to the current chain.
 //
 CBlock TestChain100Setup::CreateAndProcessBlock(
     const std::vector<CMutableTransaction> &txns, const CScript &scriptPubKey) {
     const Config &config = GetConfig();
     std::unique_ptr<CBlockTemplate> pblocktemplate =
         BlockAssembler(config, g_mempool).CreateNewBlock(scriptPubKey);
     CBlock &block = pblocktemplate->block;
 
     // Replace mempool-selected txns with just coinbase plus passed-in txns:
     block.vtx.resize(1);
     for (const CMutableTransaction &tx : txns) {
         block.vtx.push_back(MakeTransactionRef(tx));
     }
 
     // Order transactions by canonical order
     std::sort(std::begin(block.vtx) + 1, std::end(block.vtx),
               [](const std::shared_ptr<const CTransaction> &txa,
                  const std::shared_ptr<const CTransaction> &txb) -> bool {
                   return txa->GetId() < txb->GetId();
               });
 
     // IncrementExtraNonce creates a valid coinbase and merkleRoot
     unsigned int extraNonce = 0;
     {
         LOCK(cs_main);
         IncrementExtraNonce(config, &block, chainActive.Tip(), extraNonce);
     }
 
     while (!CheckProofOfWork(block.GetHash(), block.nBits, config)) {
         ++block.nNonce;
     }
 
     std::shared_ptr<const CBlock> shared_pblock =
         std::make_shared<const CBlock>(block);
     ProcessNewBlock(GetConfig(), shared_pblock, true, nullptr);
 
     CBlock result = block;
     return result;
 }
 
 TestChain100Setup::~TestChain100Setup() {}
 
 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction &tx,
                                                CTxMemPool *pool) {
     return FromTx(MakeTransactionRef(tx), pool);
 }
 
 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransactionRef &tx,
                                                CTxMemPool *pool) {
     // Hack to assume either it's completely dependent on other mempool txs or
     // not at all.
     Amount inChainValue =
         pool && pool->HasNoInputsOf(*tx) ? tx->GetValueOut() : Amount::zero();
 
     return CTxMemPoolEntry(tx, nFee, nTime, dPriority, nHeight, inChainValue,
                            spendsCoinbase, sigOpCost, lp);
 }
 
 namespace {
 // A place to put misc. setup code eg "the travis workaround" that needs to run
 // at program startup and exit
 struct Init {
     Init();
     ~Init();
 
     std::list<std::function<void(void)>> cleanup;
 };
 
 Init init;
 
 Init::Init() {
     if (getenv("TRAVIS_NOHANG_WORKAROUND")) {
         // This is a workaround for MinGW/Win32 builds on Travis sometimes
         // hanging due to no output received by Travis after a 10-minute
         // timeout.
         // The strategy here is to let the jobs finish however long they take
         // on Travis, by feeding Travis output.  We start a parallel thread
         // that just prints out '.' once per second.
         struct Private {
             Private() : stop(false) {}
             std::atomic_bool stop;
             std::thread thr;
             std::condition_variable cond;
             std::mutex mut;
         } *p = new Private;
 
         p->thr = std::thread([p] {
             // thread func.. print dots
             std::unique_lock<std::mutex> lock(p->mut);
             unsigned ctr = 0;
             while (!p->stop) {
                 if (ctr) {
                     // skip first period to allow app to print first
                     std::cerr << "." << std::flush;
                 }
                 if (!(++ctr % 79)) {
                     // newline once in a while to keep travis happy
                     std::cerr << std::endl;
                 }
                 p->cond.wait_for(lock, std::chrono::milliseconds(1000));
             }
         });
 
         cleanup.emplace_back([p]() {
             // cleanup function to kill the thread and delete the struct
             p->mut.lock();
             p->stop = true;
             p->cond.notify_all();
             p->mut.unlock();
             if (p->thr.joinable()) {
                 p->thr.join();
             }
             delete p;
         });
     }
 }
 
 Init::~Init() {
     for (auto &f : cleanup) {
         if (f) {
             f();
         }
     }
 }
 } // end anonymous namespace
diff --git a/src/test/test_bitcoin.h b/src/test/test_bitcoin.h
index e0dd2b35b..9490af2a4 100644
--- a/src/test/test_bitcoin.h
+++ b/src/test/test_bitcoin.h
@@ -1,161 +1,155 @@
 // 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.
 
 #ifndef BITCOIN_TEST_TEST_BITCOIN_H
 #define BITCOIN_TEST_TEST_BITCOIN_H
 
 #include <chainparamsbase.h>
 #include <fs.h>
 #include <key.h>
 #include <pubkey.h>
 #include <random.h>
 #include <scheduler.h>
 #include <txmempool.h>
 
 /**
  * Version of Boost::test prior to 1.64 have issues when dealing with nullptr_t.
  * In order to work around this, we ensure that the null pointers are typed in a
  * way that Boost will like better.
  *
  * TODO: Use nullptr directly once the minimum version of boost is 1.64 or more.
  */
 #define NULLPTR(T) static_cast<T *>(nullptr)
 
-extern uint256 insecure_rand_seed;
 extern FastRandomContext insecure_rand_ctx;
 
-static inline void SeedInsecureRand(bool fDeterministic = false) {
-    if (fDeterministic) {
-        insecure_rand_seed = uint256();
-    } else {
-        insecure_rand_seed = GetRandHash();
-    }
-    insecure_rand_ctx = FastRandomContext(insecure_rand_seed);
+static inline void SeedInsecureRand(bool deterministic = false) {
+    insecure_rand_ctx = FastRandomContext(deterministic);
 }
 
 static inline uint32_t insecure_rand() {
     return insecure_rand_ctx.rand32();
 }
 static inline uint256 InsecureRand256() {
     return insecure_rand_ctx.rand256();
 }
 static inline uint64_t InsecureRandBits(int bits) {
     return insecure_rand_ctx.randbits(bits);
 }
 static inline uint64_t InsecureRandRange(uint64_t range) {
     return insecure_rand_ctx.randrange(range);
 }
 static inline bool InsecureRandBool() {
     return insecure_rand_ctx.randbool();
 }
 
 /**
  * Basic testing setup.
  * This just configures logging and chain parameters.
  */
 struct BasicTestingSetup {
     ECCVerifyHandle globalVerifyHandle;
 
     explicit BasicTestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
     ~BasicTestingSetup();
 };
 
 /**
  * Testing setup that configures a complete environment.
  * Included are data directory, coins database, script check threads setup.
  */
 class CConnman;
 class CNode;
 struct CConnmanTest {
     static void AddNode(CNode &node);
     static void ClearNodes();
 };
 
 class PeerLogicValidation;
 struct TestingSetup : public BasicTestingSetup {
     fs::path pathTemp;
     boost::thread_group threadGroup;
     CConnman *connman;
     CScheduler scheduler;
     std::unique_ptr<PeerLogicValidation> peerLogic;
 
     explicit TestingSetup(
         const std::string &chainName = CBaseChainParams::MAIN);
     ~TestingSetup();
 };
 
 class CBlock;
 class CMutableTransaction;
 class CScript;
 
 //
 // Testing fixture that pre-creates a
 // 100-block REGTEST-mode block chain
 //
 struct TestChain100Setup : public TestingSetup {
     TestChain100Setup();
 
     // Create a new block with just given transactions, coinbase paying to
     // scriptPubKey, and try to add it to the current chain.
     CBlock CreateAndProcessBlock(const std::vector<CMutableTransaction> &txns,
                                  const CScript &scriptPubKey);
 
     ~TestChain100Setup();
 
     // For convenience, coinbase transactions.
     std::vector<CTransactionRef> m_coinbase_txns;
     // private/public key needed to spend coinbase transactions.
     CKey coinbaseKey;
 };
 
 class CTxMemPoolEntry;
 class CTxMemPool;
 
 struct TestMemPoolEntryHelper {
     // Default values
     Amount nFee;
     int64_t nTime;
     double dPriority;
     unsigned int nHeight;
     bool spendsCoinbase;
     unsigned int sigOpCost;
     LockPoints lp;
 
     TestMemPoolEntryHelper()
         : nFee(), nTime(0), dPriority(0.0), nHeight(1), spendsCoinbase(false),
           sigOpCost(4) {}
 
     CTxMemPoolEntry FromTx(const CMutableTransaction &tx,
                            CTxMemPool *pool = nullptr);
     CTxMemPoolEntry FromTx(const CTransactionRef &tx,
                            CTxMemPool *pool = nullptr);
 
     // Change the default value
     TestMemPoolEntryHelper &Fee(Amount _fee) {
         nFee = _fee;
         return *this;
     }
     TestMemPoolEntryHelper &Time(int64_t _time) {
         nTime = _time;
         return *this;
     }
     TestMemPoolEntryHelper &Priority(double _priority) {
         dPriority = _priority;
         return *this;
     }
     TestMemPoolEntryHelper &Height(unsigned int _height) {
         nHeight = _height;
         return *this;
     }
     TestMemPoolEntryHelper &SpendsCoinbase(bool _flag) {
         spendsCoinbase = _flag;
         return *this;
     }
     TestMemPoolEntryHelper &SigOpsCost(unsigned int _sigopsCost) {
         sigOpCost = _sigopsCost;
         return *this;
     }
 };
 #endif