diff --git a/src/random.cpp b/src/random.cpp
index 245caf51e..3e0c7610d 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -1,483 +1,486 @@
 // 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 <random.h>
 
 #ifdef WIN32
 #include <compat.h> // for Windows API
 #include <wincrypt.h>
 #endif
 #include <crypto/sha512.h>
 #include <logging.h> // for LogPrint()
 #include <support/cleanse.h>
 #include <sync.h>     // for WAIT_LOCK
 #include <utiltime.h> // for GetTime()
 
 #include <openssl/err.h>
 #include <openssl/rand.h>
 
 #include <chrono>
 #include <cstdlib>
 #include <limits>
 #include <mutex>
 #include <thread>
 #ifndef WIN32
 #include <fcntl.h>
 #include <sys/time.h>
 #endif
 
 #ifdef HAVE_SYS_GETRANDOM
 #include <linux/random.h>
 #include <sys/syscall.h>
 #endif
 #if defined(HAVE_GETENTROPY) ||                                                \
     (defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX))
 #include <unistd.h>
 #endif
 #if defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX)
 #include <sys/random.h>
 #endif
 #ifdef HAVE_SYSCTL_ARND
 #include <sys/sysctl.h>
 #include <utilstrencodings.h> // for ARRAYLEN
 #endif
 
 #if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
 #include <cpuid.h>
 #endif
 
 [[noreturn]] static void RandFailure() {
     LogPrintf("Failed to read randomness, aborting\n");
     std::abort();
 }
 
 static inline int64_t GetPerformanceCounter() {
 // Read the hardware time stamp counter when available.
 // See https://en.wikipedia.org/wiki/Time_Stamp_Counter for more information.
 #if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))
     return __rdtsc();
 #elif !defined(_MSC_VER) && defined(__i386__)
     uint64_t r = 0;
     // Constrain the r variable to the eax:edx pair.
     __asm__ volatile("rdtsc" : "=A"(r));
     return r;
 #elif !defined(_MSC_VER) && (defined(__x86_64__) || defined(__amd64__))
     uint64_t r1 = 0, r2 = 0;
     // Constrain r1 to rax and r2 to rdx.
     __asm__ volatile("rdtsc" : "=a"(r1), "=d"(r2));
     return (r2 << 32) | r1;
 #else
     // Fall back to using C++11 clock (usually microsecond or nanosecond
     // precision)
     return std::chrono::high_resolution_clock::now().time_since_epoch().count();
 #endif
 }
 
 #if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
 static std::atomic<bool> hwrand_initialized{false};
 static bool rdrand_supported = false;
 static constexpr uint32_t CPUID_F1_ECX_RDRAND = 0x40000000;
 static void RDRandInit() {
     uint32_t eax, ebx, ecx, edx;
     if (__get_cpuid(1, &eax, &ebx, &ecx, &edx) && (ecx & CPUID_F1_ECX_RDRAND)) {
         LogPrintf("Using RdRand as an additional entropy source\n");
         rdrand_supported = true;
     }
     hwrand_initialized.store(true);
 }
 #else
 static void RDRandInit() {}
 #endif
 
 static bool GetHWRand(uint8_t *ent32) {
 #if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
     assert(hwrand_initialized.load(std::memory_order_relaxed));
     if (rdrand_supported) {
         uint8_t ok;
 // Not all assemblers support the rdrand instruction, write it in hex.
 #ifdef __i386__
         for (int iter = 0; iter < 4; ++iter) {
             uint32_t r1, r2;
             __asm__ volatile(".byte 0x0f, 0xc7, 0xf0;" // rdrand %eax
                              ".byte 0x0f, 0xc7, 0xf2;" // rdrand %edx
                              "setc %2"
                              : "=a"(r1), "=d"(r2), "=q"(ok)::"cc");
             if (!ok) {
                 return false;
             }
             WriteLE32(ent32 + 8 * iter, r1);
             WriteLE32(ent32 + 8 * iter + 4, r2);
         }
 #else
         uint64_t r1, r2, r3, r4;
         __asm__ volatile(".byte 0x48, 0x0f, 0xc7, 0xf0, " // rdrand %rax
                          "0x48, 0x0f, 0xc7, 0xf3, "       // rdrand %rbx
                          "0x48, 0x0f, 0xc7, 0xf1, "       // rdrand %rcx
                          "0x48, 0x0f, 0xc7, 0xf2; "       // rdrand %rdx
                          "setc %4"
                          : "=a"(r1), "=b"(r2), "=c"(r3), "=d"(r4),
                            "=q"(ok)::"cc");
         if (!ok) {
             return false;
         }
         WriteLE64(ent32, r1);
         WriteLE64(ent32 + 8, r2);
         WriteLE64(ent32 + 16, r3);
         WriteLE64(ent32 + 24, r4);
 #endif
         return true;
     }
 #endif
     return false;
 }
 
 void RandAddSeed() {
     // Seed with CPU performance counter
     int64_t nCounter = GetPerformanceCounter();
     RAND_add(&nCounter, sizeof(nCounter), 1.5);
     memory_cleanse((void *)&nCounter, sizeof(nCounter));
 }
 
 static void RandAddSeedPerfmon() {
     RandAddSeed();
 
 #ifdef WIN32
     // Don't need this on Linux, OpenSSL automatically uses /dev/urandom
     // Seed with the entire set of perfmon data
 
     // This can take up to 2 seconds, so only do it every 10 minutes
     static int64_t nLastPerfmon;
     if (GetTime() < nLastPerfmon + 10 * 60) {
         return;
     }
     nLastPerfmon = GetTime();
 
     std::vector<uint8_t> vData(250000, 0);
     long ret = 0;
     unsigned long nSize = 0;
     // Bail out at more than 10MB of performance data
     const size_t nMaxSize = 10000000;
     while (true) {
         nSize = vData.size();
         ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", nullptr,
                                nullptr, vData.data(), &nSize);
         if (ret != ERROR_MORE_DATA || vData.size() >= nMaxSize) {
             break;
         }
         // Grow size of buffer exponentially
         vData.resize(std::max((vData.size() * 3) / 2, nMaxSize));
     }
     RegCloseKey(HKEY_PERFORMANCE_DATA);
     if (ret == ERROR_SUCCESS) {
         RAND_add(vData.data(), nSize, nSize / 100.0);
         memory_cleanse(vData.data(), nSize);
         LogPrint(BCLog::RAND, "%s: %lu bytes\n", __func__, nSize);
     } else {
         // Warn only once
         static bool warned = false;
         if (!warned) {
             LogPrintf("%s: Warning: RegQueryValueExA(HKEY_PERFORMANCE_DATA) "
                       "failed with code %i\n",
                       __func__, ret);
             warned = true;
         }
     }
 #endif
 }
 
 #ifndef WIN32
 /**
  * Fallback: get 32 bytes of system entropy from /dev/urandom. The most
  * compatible way to get cryptographic randomness on UNIX-ish platforms.
  */
 static void GetDevURandom(uint8_t *ent32) {
     int f = open("/dev/urandom", O_RDONLY);
     if (f == -1) {
         RandFailure();
     }
     int have = 0;
     do {
         ssize_t n = read(f, ent32 + have, NUM_OS_RANDOM_BYTES - have);
         if (n <= 0 || n + have > NUM_OS_RANDOM_BYTES) {
             close(f);
             RandFailure();
         }
         have += n;
     } while (have < NUM_OS_RANDOM_BYTES);
     close(f);
 }
 #endif
 
 /** Get 32 bytes of system entropy. */
 void GetOSRand(uint8_t *ent32) {
 #if defined(WIN32)
     HCRYPTPROV hProvider;
     int ret = CryptAcquireContextW(&hProvider, nullptr, nullptr, PROV_RSA_FULL,
                                    CRYPT_VERIFYCONTEXT);
     if (!ret) {
         RandFailure();
     }
     ret = CryptGenRandom(hProvider, NUM_OS_RANDOM_BYTES, ent32);
     if (!ret) {
         RandFailure();
     }
     CryptReleaseContext(hProvider, 0);
 #elif defined(HAVE_SYS_GETRANDOM)
     /**
      * Linux. From the getrandom(2) man page:
      * "If the urandom source has been initialized, reads of up to 256 bytes
      * will always return as many bytes as requested and will not be interrupted
      * by signals."
      */
     int rv = syscall(SYS_getrandom, ent32, NUM_OS_RANDOM_BYTES, 0);
     if (rv != NUM_OS_RANDOM_BYTES) {
         if (rv < 0 && errno == ENOSYS) {
             /* Fallback for kernel <3.17: the return value will be -1 and errno
              * ENOSYS if the syscall is not available, in that case fall back
              * to /dev/urandom.
              */
             GetDevURandom(ent32);
         } else {
             RandFailure();
         }
     }
 #elif defined(HAVE_GETENTROPY) && defined(__OpenBSD__)
     /**
      * On OpenBSD this can return up to 256 bytes of entropy, will return an
      * error if more are requested.
      * The call cannot return less than the requested number of bytes.
      * getentropy is explicitly limited to openbsd here, as a similar (but not
      * the same) function may exist on other platforms via glibc.
      */
     if (getentropy(ent32, NUM_OS_RANDOM_BYTES) != 0) {
         RandFailure();
     }
 #elif defined(HAVE_GETENTROPY_RAND) && defined(MAC_OSX)
     // We need a fallback for OSX < 10.12
     if (&getentropy != nullptr) {
         if (getentropy(ent32, NUM_OS_RANDOM_BYTES) != 0) {
             RandFailure();
         }
     } else {
         GetDevURandom(ent32);
     }
 #elif defined(HAVE_SYSCTL_ARND)
     /**
      * FreeBSD and similar. It is possible for the call to return less bytes
      * than requested, so need to read in a loop.
      */
     static const int name[2] = {CTL_KERN, KERN_ARND};
     int have = 0;
     do {
         size_t len = NUM_OS_RANDOM_BYTES - have;
         if (sysctl(name, ARRAYLEN(name), ent32 + have, &len, nullptr, 0) != 0) {
             RandFailure();
         }
         have += len;
     } while (have < NUM_OS_RANDOM_BYTES);
 #else
     /**
      * Fall back to /dev/urandom if there is no specific method implemented to
      * get system entropy for this OS.
      */
     GetDevURandom(ent32);
 #endif
 }
 
 void GetRandBytes(uint8_t *buf, int num) {
     if (RAND_bytes(buf, num) != 1) {
         RandFailure();
     }
 }
 
 static void AddDataToRng(void *data, size_t len);
 
 void RandAddSeedSleep() {
     int64_t nPerfCounter1 = GetPerformanceCounter();
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
     int64_t nPerfCounter2 = GetPerformanceCounter();
 
     // Combine with and update state
     AddDataToRng(&nPerfCounter1, sizeof(nPerfCounter1));
     AddDataToRng(&nPerfCounter2, sizeof(nPerfCounter2));
 
     memory_cleanse(&nPerfCounter1, sizeof(nPerfCounter1));
     memory_cleanse(&nPerfCounter2, sizeof(nPerfCounter2));
 }
 
 static Mutex cs_rng_state;
 static uint8_t rng_state[32] = {0};
 static uint64_t rng_counter = 0;
 
 static void AddDataToRng(void *data, size_t len) {
     CSHA512 hasher;
     hasher.Write((const uint8_t *)&len, sizeof(len));
     hasher.Write((const uint8_t *)data, len);
     uint8_t buf[64];
     {
         WAIT_LOCK(cs_rng_state, lock);
         hasher.Write(rng_state, sizeof(rng_state));
         hasher.Write((const uint8_t *)&rng_counter, sizeof(rng_counter));
         ++rng_counter;
         hasher.Finalize(buf);
         memcpy(rng_state, buf + 32, 32);
     }
     memory_cleanse(buf, 64);
 }
 
 void GetStrongRandBytes(uint8_t *out, int num) {
     assert(num <= 32);
     CSHA512 hasher;
     uint8_t buf[64];
 
     // First source: OpenSSL's RNG
     RandAddSeedPerfmon();
     GetRandBytes(buf, 32);
     hasher.Write(buf, 32);
 
     // Second source: OS RNG
     GetOSRand(buf);
     hasher.Write(buf, 32);
 
     // Third source: HW RNG, if available.
     if (GetHWRand(buf)) {
         hasher.Write(buf, 32);
     }
 
     // Combine with and update state
     {
         WAIT_LOCK(cs_rng_state, lock);
         hasher.Write(rng_state, sizeof(rng_state));
         hasher.Write((const uint8_t *)&rng_counter, sizeof(rng_counter));
         ++rng_counter;
         hasher.Finalize(buf);
         memcpy(rng_state, buf + 32, 32);
     }
 
     // Produce output
     memcpy(out, buf, num);
     memory_cleanse(buf, 64);
 }
 
 uint64_t GetRand(uint64_t nMax) {
     if (nMax == 0) {
         return 0;
     }
 
     // The range of the random source must be a multiple of the modulus to give
     // every possible output value an equal possibility
     uint64_t nRange = (std::numeric_limits<uint64_t>::max() / nMax) * nMax;
     uint64_t nRand = 0;
     do {
         GetRandBytes((uint8_t *)&nRand, sizeof(nRand));
     } while (nRand >= nRange);
     return (nRand % nMax);
 }
 
 int GetRandInt(int nMax) {
     return GetRand(nMax);
 }
 
 uint256 GetRandHash() {
     uint256 hash;
     GetRandBytes((uint8_t *)&hash, sizeof(hash));
     return hash;
 }
 
 void FastRandomContext::RandomSeed() {
     uint256 seed = GetRandHash();
     rng.SetKey(seed.begin(), 32);
     requires_seed = false;
 }
 
 uint256 FastRandomContext::rand256() {
     if (bytebuf_size < 32) {
         FillByteBuffer();
     }
     uint256 ret;
     memcpy(ret.begin(), bytebuf + 64 - bytebuf_size, 32);
     bytebuf_size -= 32;
     return ret;
 }
 
 std::vector<uint8_t> FastRandomContext::randbytes(size_t len) {
+    if (requires_seed) {
+        RandomSeed();
+    }
     std::vector<uint8_t> ret(len);
     if (len > 0) {
         rng.Output(&ret[0], len);
     }
     return ret;
 }
 
 FastRandomContext::FastRandomContext(const uint256 &seed)
     : requires_seed(false), bytebuf_size(0), bitbuf_size(0) {
     rng.SetKey(seed.begin(), 32);
 }
 
 bool Random_SanityCheck() {
     uint64_t start = GetPerformanceCounter();
 
     /**
      * This does not measure the quality of randomness, but it does test that
      * OSRandom() overwrites all 32 bytes of the output given a maximum number
      * of tries.
      */
     static const ssize_t MAX_TRIES = 1024;
     uint8_t data[NUM_OS_RANDOM_BYTES];
     /* Tracks which bytes have been overwritten at least once */
     bool overwritten[NUM_OS_RANDOM_BYTES] = {};
     int num_overwritten;
     int tries = 0;
     /**
      * Loop until all bytes have been overwritten at least once, or max number
      * tries reached.
      */
     do {
         memset(data, 0, NUM_OS_RANDOM_BYTES);
         GetOSRand(data);
         for (int x = 0; x < NUM_OS_RANDOM_BYTES; ++x) {
             overwritten[x] |= (data[x] != 0);
         }
 
         num_overwritten = 0;
         for (int x = 0; x < NUM_OS_RANDOM_BYTES; ++x) {
             if (overwritten[x]) {
                 num_overwritten += 1;
             }
         }
 
         tries += 1;
     } while (num_overwritten < NUM_OS_RANDOM_BYTES && tries < MAX_TRIES);
     /* If this failed, bailed out after too many tries */
     if (num_overwritten != NUM_OS_RANDOM_BYTES) {
         return false;
     }
 
     // Check that GetPerformanceCounter increases at least during a GetOSRand()
     // call + 1ms sleep.
     std::this_thread::sleep_for(std::chrono::milliseconds(1));
     uint64_t stop = GetPerformanceCounter();
     if (stop == start) {
         return false;
     }
 
     // We called GetPerformanceCounter. Use it as entropy.
     RAND_add((const uint8_t *)&start, sizeof(start), 1);
     RAND_add((const uint8_t *)&stop, sizeof(stop), 1);
 
     return true;
 }
 
 FastRandomContext::FastRandomContext(bool fDeterministic)
     : requires_seed(!fDeterministic), bytebuf_size(0), bitbuf_size(0) {
     if (!fDeterministic) {
         return;
     }
     uint256 seed;
     rng.SetKey(seed.begin(), 32);
 }
 
 void RandomInit() {
     RDRandInit();
 }
diff --git a/src/test/random_tests.cpp b/src/test/random_tests.cpp
index 0f354c35f..319a17ca5 100644
--- a/src/test/random_tests.cpp
+++ b/src/test/random_tests.cpp
@@ -1,78 +1,85 @@
 // Copyright (c) 2017 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 <random.h>
 
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>
 #include <random>
 
 BOOST_FIXTURE_TEST_SUITE(random_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(osrandom_tests) {
     BOOST_CHECK(Random_SanityCheck());
 }
 
 BOOST_AUTO_TEST_CASE(fastrandom_tests) {
     // Check that deterministic FastRandomContexts are deterministic
     FastRandomContext ctx1(true);
     FastRandomContext ctx2(true);
 
     BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());
     BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());
     BOOST_CHECK_EQUAL(ctx1.rand64(), ctx2.rand64());
     BOOST_CHECK_EQUAL(ctx1.randbits(3), ctx2.randbits(3));
     BOOST_CHECK(ctx1.randbytes(17) == ctx2.randbytes(17));
     BOOST_CHECK(ctx1.rand256() == ctx2.rand256());
     BOOST_CHECK_EQUAL(ctx1.randbits(7), ctx2.randbits(7));
     BOOST_CHECK(ctx1.randbytes(128) == ctx2.randbytes(128));
     BOOST_CHECK_EQUAL(ctx1.rand32(), ctx2.rand32());
     BOOST_CHECK_EQUAL(ctx1.randbits(3), ctx2.randbits(3));
     BOOST_CHECK(ctx1.rand256() == ctx2.rand256());
     BOOST_CHECK(ctx1.randbytes(50) == ctx2.randbytes(50));
 
     // Check that a nondeterministic ones are not
-    FastRandomContext ctx3;
-    FastRandomContext ctx4;
-    // extremely unlikely to be equal
-    BOOST_CHECK(ctx3.rand64() != ctx4.rand64());
-    BOOST_CHECK(ctx3.rand256() != ctx4.rand256());
-    BOOST_CHECK(ctx3.randbytes(7) != ctx4.randbytes(7));
+    {
+        FastRandomContext ctx3, ctx4;
+        // extremely unlikely to be equal
+        BOOST_CHECK(ctx3.rand64() != ctx4.rand64());
+    }
+    {
+        FastRandomContext ctx3, ctx4;
+        BOOST_CHECK(ctx3.rand256() != ctx4.rand256());
+    }
+    {
+        FastRandomContext ctx3, ctx4;
+        BOOST_CHECK(ctx3.randbytes(7) != ctx4.randbytes(7));
+    }
 }
 
 BOOST_AUTO_TEST_CASE(fastrandom_randbits) {
     FastRandomContext ctx1;
     FastRandomContext ctx2;
     for (int bits = 0; bits < 63; ++bits) {
         for (int j = 0; j < 1000; ++j) {
             uint64_t rangebits = ctx1.randbits(bits);
             BOOST_CHECK_EQUAL(rangebits >> bits, uint64_t(0));
             uint64_t range = uint64_t(1) << bits | rangebits;
             uint64_t rand = ctx2.randrange(range);
             BOOST_CHECK(rand < range);
         }
     }
 }
 
 /** Does-it-compile test for compatibility with standard C++11 RNG interface. */
 BOOST_AUTO_TEST_CASE(stdrandom_test) {
     FastRandomContext ctx;
     std::uniform_int_distribution<int> distribution(3, 9);
     for (int i = 0; i < 100; ++i) {
         int x = distribution(ctx);
         BOOST_CHECK(x >= 3);
         BOOST_CHECK(x <= 9);
 
         std::vector<int> test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
         std::shuffle(test.begin(), test.end(), ctx);
         for (int j = 1; j <= 10; ++j) {
             BOOST_CHECK(std::find(test.begin(), test.end(), j) != test.end());
         }
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()