diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1eca5375c41..01e044f4227 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -46,6 +46,14 @@
 # 0.49.0 - [unreleased]
 
 - Update to [`libp2p-tcp` `v0.37.0`](transports/tcp/CHANGELOG.md#0370).
+- Update individual crates.
+    - Update to [`libp2p-ping` `v0.39.1`](protocols/ping/CHANGELOG.md#0391).
+    - Update to [`libp2p-floodsub` `v0.39.1`](protocols/floodsub/CHANGELOG.md#0391).
+    - Update to [`libp2p-gossipsub` `v0.41.1`](protocols/gossipsub/CHANGELOG.md#0411).
+    - Update to [`libp2p-request-response` `v0.21.1`](protocols/request-response/CHANGELOG.md#0211).
+    - Update to [`libp2p-pnet` `v0.22.1`](transports/pnet/CHANGELOG.md#0221).
+    - Update to [`libp2p-mplex` `v0.36.1`](muxers/mplex/CHANGELOG.md#0361).
+    - Update to [`libp2p-swarm` `v0.39.1`](swarm/CHANGELOG.md#0391).
 - 
 - Update to [`libp2p-noise` `v0.39.1`](transports/noise/CHANGELOG.md#0391).
 
diff --git a/Cargo.toml b/Cargo.toml
index a14405eff6b..0a4344d184a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -60,7 +60,7 @@ rendezvous = ["dep:libp2p-rendezvous"]
 tcp-async-io = ["dep:libp2p-tcp", "libp2p-tcp?/async-io"]
 tcp-tokio = ["dep:libp2p-tcp", "libp2p-tcp?/tokio"]
 uds = ["dep:libp2p-uds"]
-wasm-bindgen = ["futures-timer/wasm-bindgen", "instant/wasm-bindgen", "getrandom/js", "rand/wasm-bindgen"]
+wasm-bindgen = ["futures-timer/wasm-bindgen", "instant/wasm-bindgen", "getrandom/js"]
 wasm-ext = ["dep:libp2p-wasm-ext"]
 wasm-ext-websocket = ["wasm-ext", "libp2p-wasm-ext?/websocket"]
 websocket = ["dep:libp2p-websocket"]
@@ -83,19 +83,19 @@ lazy_static = "1.2"
 libp2p-autonat = { version = "0.7.0", path = "protocols/autonat", optional = true }
 libp2p-core = { version = "0.36.0", path = "core",  default-features = false }
 libp2p-dcutr = { version = "0.6.0", path = "protocols/dcutr",  optional = true }
-libp2p-floodsub = { version = "0.39.0", path = "protocols/floodsub", optional = true }
+libp2p-floodsub = { version = "0.39.1", path = "protocols/floodsub", optional = true }
 libp2p-identify = { version = "0.39.0", path = "protocols/identify", optional = true }
 libp2p-kad = { version = "0.41.0", path = "protocols/kad", optional = true }
 libp2p-metrics = { version = "0.10.0", path = "misc/metrics", optional = true }
-libp2p-mplex = { version = "0.36.0", path = "muxers/mplex", optional = true }
+libp2p-mplex = { version = "0.36.1", path = "muxers/mplex", optional = true }
 libp2p-noise = { version = "0.39.1", path = "transports/noise", optional = true }
-libp2p-ping = { version = "0.39.0", path = "protocols/ping", optional = true }
+libp2p-ping = { version = "0.39.1", path = "protocols/ping", optional = true }
 libp2p-plaintext = { version = "0.36.0", path = "transports/plaintext", optional = true }
-libp2p-pnet = { version = "0.22.0", path = "transports/pnet", optional = true }
+libp2p-pnet = { version = "0.22.1", path = "transports/pnet", optional = true }
 libp2p-relay = { version = "0.12.0", path = "protocols/relay", optional = true }
 libp2p-rendezvous = { version = "0.9.0", path = "protocols/rendezvous", optional = true }
-libp2p-request-response = { version = "0.21.0", path = "protocols/request-response", optional = true }
-libp2p-swarm = { version = "0.39.0", path = "swarm" }
+libp2p-request-response = { version = "0.21.1", path = "protocols/request-response", optional = true }
+libp2p-swarm = { version = "0.39.1", path = "swarm" }
 libp2p-swarm-derive = { version = "0.30.1", path = "swarm-derive" }
 libp2p-uds = { version = "0.35.0", path = "transports/uds", optional = true }
 libp2p-wasm-ext = { version = "0.36.0", path = "transports/wasm-ext", default-features = false, optional = true }
@@ -103,7 +103,6 @@ libp2p-yamux = { version = "0.40.0", path = "muxers/yamux", optional = true }
 multiaddr = { version = "0.14.0" }
 parking_lot = "0.12.0"
 pin-project = "1.0.0"
-rand = "0.7.3" # Explicit dependency to be used in `wasm-bindgen` feature
 smallvec = "1.6.1"
 
 [target.'cfg(not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown")))'.dependencies]
@@ -114,7 +113,7 @@ libp2p-tcp = { version = "0.37.0", path = "transports/tcp", default-features = f
 libp2p-websocket = { version = "0.38.0", path = "transports/websocket", optional = true }
 
 [target.'cfg(not(target_os = "unknown"))'.dependencies]
-libp2p-gossipsub = { version = "0.41.0", path = "protocols/gossipsub", optional = true }
+libp2p-gossipsub = { version = "0.41.1", path = "protocols/gossipsub", optional = true }
 
 [dev-dependencies]
 async-std = { version = "1.6.2", features = ["attributes"] }
@@ -131,6 +130,7 @@ members = [
     "misc/rw-stream-sink",
     "misc/keygen",
     "misc/prost-codec",
+    "misc/quickcheck-ext",
     "muxers/mplex",
     "muxers/yamux",
     "protocols/dcutr",
diff --git a/core/Cargo.toml b/core/Cargo.toml
index 0505ccd970d..8390c75898e 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -48,8 +48,7 @@ base64 = "0.13.0"
 criterion = "0.4"
 libp2p = { path = "../", default-features = false, features = ["mplex", "noise"] }
 multihash = { version = "0.16", default-features = false, features = ["arb"] }
-quickcheck = "0.9.0"
-rand07 = { package = "rand", version = "0.7" }
+quickcheck = { package = "quickcheck-ext", path = "../misc/quickcheck-ext" }
 rmp-serde = "1.0"
 serde_json = "1.0"
 
diff --git a/core/src/identity/rsa.rs b/core/src/identity/rsa.rs
index 40a7ea6f144..1d20f00aefd 100644
--- a/core/src/identity/rsa.rs
+++ b/core/src/identity/rsa.rs
@@ -306,7 +306,6 @@ impl DerDecodable<'_> for Asn1SubjectPublicKeyInfo {
 mod tests {
     use super::*;
     use quickcheck::*;
-    use rand07::seq::SliceRandom;
     use std::fmt;
 
     const KEY1: &'static [u8] = include_bytes!("test/rsa-2048.pk8");
@@ -323,8 +322,8 @@ mod tests {
     }
 
     impl Arbitrary for SomeKeypair {
-        fn arbitrary<G: Gen>(g: &mut G) -> SomeKeypair {
-            let mut key = [KEY1, KEY2, KEY3].choose(g).unwrap().to_vec();
+        fn arbitrary(g: &mut Gen) -> SomeKeypair {
+            let mut key = g.choose(&[KEY1, KEY2, KEY3]).unwrap().to_vec();
             SomeKeypair(Keypair::from_pkcs8(&mut key).unwrap())
         }
     }
diff --git a/misc/multistream-select/Cargo.toml b/misc/multistream-select/Cargo.toml
index 401902d12f2..5fd65270d97 100644
--- a/misc/multistream-select/Cargo.toml
+++ b/misc/multistream-select/Cargo.toml
@@ -22,6 +22,6 @@ unsigned-varint = "0.7"
 async-std = "1.6.2"
 env_logger = "0.9"
 libp2p = { path = "../../", default-features = false, features = ["mplex", "plaintext"] }
-quickcheck = "0.9.0"
-rand = "0.7.2"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
+rand = "0.8"
 rw-stream-sink = { version = "0.3.0", path = "../../misc/rw-stream-sink" }
diff --git a/misc/multistream-select/src/protocol.rs b/misc/multistream-select/src/protocol.rs
index d1374ef7495..b762aa34343 100644
--- a/misc/multistream-select/src/protocol.rs
+++ b/misc/multistream-select/src/protocol.rs
@@ -455,15 +455,14 @@ impl fmt::Display for ProtocolError {
 mod tests {
     use super::*;
     use quickcheck::*;
-    use rand::distributions::Alphanumeric;
-    use rand::Rng;
     use std::iter;
 
     impl Arbitrary for Protocol {
-        fn arbitrary<G: Gen>(g: &mut G) -> Protocol {
-            let n = g.gen_range(1, g.size());
+        fn arbitrary(g: &mut Gen) -> Protocol {
+            let n = g.gen_range(1..g.size());
             let p: String = iter::repeat(())
-                .map(|()| g.sample(Alphanumeric))
+                .map(|()| char::arbitrary(g))
+                .filter(|&c| c.is_ascii_alphanumeric())
                 .take(n)
                 .collect();
             Protocol(Bytes::from(format!("/{}", p)))
@@ -471,8 +470,8 @@ mod tests {
     }
 
     impl Arbitrary for Message {
-        fn arbitrary<G: Gen>(g: &mut G) -> Message {
-            match g.gen_range(0, 5) {
+        fn arbitrary(g: &mut Gen) -> Message {
+            match g.gen_range(0..5u8) {
                 0 => Message::Header(HeaderLine::V1),
                 1 => Message::NotAvailable,
                 2 => Message::ListProtocols,
diff --git a/misc/quickcheck-ext/Cargo.toml b/misc/quickcheck-ext/Cargo.toml
new file mode 100644
index 00000000000..0c427dc4fc9
--- /dev/null
+++ b/misc/quickcheck-ext/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "quickcheck-ext"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "Unlicense/MIT"
+
+[dependencies]
+quickcheck = "1"
+num-traits = "0.2"
diff --git a/misc/quickcheck-ext/src/lib.rs b/misc/quickcheck-ext/src/lib.rs
new file mode 100644
index 00000000000..392c9f0f8aa
--- /dev/null
+++ b/misc/quickcheck-ext/src/lib.rs
@@ -0,0 +1,44 @@
+pub use quickcheck::*;
+
+use core::ops::Range;
+use num_traits::sign::Unsigned;
+
+pub trait GenRange {
+    fn gen_range<T: Unsigned + Arbitrary + Copy>(&mut self, _range: Range<T>) -> T;
+
+    fn gen_index(&mut self, ubound: usize) -> usize {
+        if ubound <= (core::u32::MAX as usize) {
+            self.gen_range(0..ubound as u32) as usize
+        } else {
+            self.gen_range(0..ubound)
+        }
+    }
+}
+
+impl GenRange for Gen {
+    fn gen_range<T: Unsigned + Arbitrary + Copy>(&mut self, range: Range<T>) -> T {
+        <T as Arbitrary>::arbitrary(self) % (range.end - range.start) + range.start
+    }
+}
+
+pub trait SliceRandom {
+    fn shuffle<T>(&mut self, arr: &mut [T]);
+    fn choose_multiple<'a, T>(
+        &mut self,
+        arr: &'a [T],
+        amount: usize,
+    ) -> std::iter::Take<std::vec::IntoIter<&'a T>> {
+        let mut v: Vec<&T> = arr.iter().collect();
+        self.shuffle(&mut v);
+        v.into_iter().take(amount)
+    }
+}
+
+impl SliceRandom for Gen {
+    fn shuffle<T>(&mut self, arr: &mut [T]) {
+        for i in (1..arr.len()).rev() {
+            // invariant: elements with index > i have been locked in place.
+            arr.swap(i, self.gen_index(i + 1));
+        }
+    }
+}
diff --git a/muxers/mplex/CHANGELOG.md b/muxers/mplex/CHANGELOG.md
index 925013d1e29..b02b9d05342 100644
--- a/muxers/mplex/CHANGELOG.md
+++ b/muxers/mplex/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.36.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.36.0
 
 - Update to `libp2p-core` `v0.36.0`
diff --git a/muxers/mplex/Cargo.toml b/muxers/mplex/Cargo.toml
index 0fcf1fcf352..04d28907ef2 100644
--- a/muxers/mplex/Cargo.toml
+++ b/muxers/mplex/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-mplex"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Mplex multiplexing protocol for libp2p"
-version = "0.36.0"
+version = "0.36.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -18,7 +18,7 @@ libp2p-core = { version = "0.36.0", path = "../../core", default-features = fals
 log = "0.4"
 nohash-hasher = "0.2"
 parking_lot = "0.12"
-rand = "0.7"
+rand = "0.8"
 smallvec = "1.6.1"
 unsigned-varint = { version = "0.7", features = ["asynchronous_codec"] }
 
@@ -28,8 +28,7 @@ criterion = "0.4"
 env_logger = "0.9"
 futures = "0.3"
 libp2p = { path = "../../", default-features = false, features = ["tcp-async-io", "plaintext", "mplex"] }
-quickcheck = "0.9"
-rand = "0.7"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 
 [[bench]]
 name = "split_send_size"
diff --git a/muxers/mplex/src/io.rs b/muxers/mplex/src/io.rs
index bbb11943201..c5ad6bf105d 100644
--- a/muxers/mplex/src/io.rs
+++ b/muxers/mplex/src/io.rs
@@ -1105,27 +1105,25 @@ mod tests {
     use asynchronous_codec::{Decoder, Encoder};
     use bytes::BytesMut;
     use quickcheck::*;
-    use rand::prelude::*;
     use std::collections::HashSet;
     use std::num::NonZeroU8;
     use std::ops::DerefMut;
     use std::pin::Pin;
 
     impl Arbitrary for MaxBufferBehaviour {
-        fn arbitrary<G: Gen>(g: &mut G) -> MaxBufferBehaviour {
-            *[MaxBufferBehaviour::Block, MaxBufferBehaviour::ResetStream]
-                .choose(g)
+        fn arbitrary(g: &mut Gen) -> MaxBufferBehaviour {
+            *g.choose(&[MaxBufferBehaviour::Block, MaxBufferBehaviour::ResetStream])
                 .unwrap()
         }
     }
 
     impl Arbitrary for MplexConfig {
-        fn arbitrary<G: Gen>(g: &mut G) -> MplexConfig {
+        fn arbitrary(g: &mut Gen) -> MplexConfig {
             MplexConfig {
-                max_substreams: g.gen_range(1, 100),
-                max_buffer_len: g.gen_range(1, 1000),
+                max_substreams: g.gen_range(1..100),
+                max_buffer_len: g.gen_range(1..1000),
                 max_buffer_behaviour: MaxBufferBehaviour::arbitrary(g),
-                split_send_size: g.gen_range(1, 10000),
+                split_send_size: g.gen_range(1..10000),
                 protocol_name: crate::config::DEFAULT_MPLEX_PROTOCOL_NAME,
             }
         }
diff --git a/protocols/dcutr/Cargo.toml b/protocols/dcutr/Cargo.toml
index 155335763d4..d53d92d32c3 100644
--- a/protocols/dcutr/Cargo.toml
+++ b/protocols/dcutr/Cargo.toml
@@ -31,5 +31,5 @@ prost-build = "0.11"
 [dev-dependencies]
 env_logger = "0.9.0"
 libp2p = { path = "../..", default-features = false,  features = ["dcutr", "relay", "plaintext", "identify", "tcp-async-io", "ping", "noise", "dns-async-std", "yamux"] }
-rand = "0.7"
+rand = "0.8"
 clap = {version = "3.1.6", features = ["derive"]}
diff --git a/protocols/floodsub/CHANGELOG.md b/protocols/floodsub/CHANGELOG.md
index 5a91e14642a..0770b97bed8 100644
--- a/protocols/floodsub/CHANGELOG.md
+++ b/protocols/floodsub/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.39.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.39.0
 
 - Update to `libp2p-swarm` `v0.39.0`.
diff --git a/protocols/floodsub/Cargo.toml b/protocols/floodsub/Cargo.toml
index 58977415005..e89bbd3fdb7 100644
--- a/protocols/floodsub/Cargo.toml
+++ b/protocols/floodsub/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-floodsub"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Floodsub protocol for libp2p"
-version = "0.39.0"
+version = "0.39.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -18,7 +18,7 @@ libp2p-core = { version = "0.36.0", path = "../../core", default-features = fals
 libp2p-swarm = { version = "0.39.0", path = "../../swarm" }
 log = "0.4"
 prost = "0.11"
-rand = "0.7"
+rand = "0.8"
 smallvec = "1.6.1"
 
 [build-dependencies]
diff --git a/protocols/gossipsub/CHANGELOG.md b/protocols/gossipsub/CHANGELOG.md
index 1ba36ad6607..4699fe664a5 100644
--- a/protocols/gossipsub/CHANGELOG.md
+++ b/protocols/gossipsub/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.41.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.41.0
 
 - Update to `libp2p-swarm` `v0.39.0`.
diff --git a/protocols/gossipsub/Cargo.toml b/protocols/gossipsub/Cargo.toml
index 2e69b0380dc..b99788f59e1 100644
--- a/protocols/gossipsub/Cargo.toml
+++ b/protocols/gossipsub/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-gossipsub"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Gossipsub protocol for libp2p"
-version = "0.41.0"
+version = "0.41.1"
 authors = ["Age Manning <Age@AgeManning.com>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -17,7 +17,7 @@ bytes = "1.0"
 byteorder = "1.3.4"
 fnv = "1.0.7"
 futures = "0.3.5"
-rand = "0.7.3"
+rand = "0.8"
 asynchronous-codec = "0.6"
 unsigned-varint = { version = "0.7.0", features = ["asynchronous_codec"] }
 log = "0.4.11"
@@ -37,7 +37,7 @@ prometheus-client = "0.18.0"
 async-std = "1.6.3"
 env_logger = "0.9.0"
 libp2p = { path = "../../", default-features = false, features = ["plaintext", "yamux", "noise", "mplex", "gossipsub"] }
-quickcheck = "0.9.2"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 hex = "0.4.2"
 derive_builder = "0.11.1"
 
diff --git a/protocols/gossipsub/src/behaviour.rs b/protocols/gossipsub/src/behaviour.rs
index 21dd77562df..43f2f79466d 100644
--- a/protocols/gossipsub/src/behaviour.rs
+++ b/protocols/gossipsub/src/behaviour.rs
@@ -3664,7 +3664,6 @@ mod local_test {
     use crate::IdentTopic;
     use asynchronous_codec::Encoder;
     use quickcheck::*;
-    use rand::Rng;
 
     fn empty_rpc() -> GossipsubRpc {
         GossipsubRpc {
@@ -3701,16 +3700,16 @@ mod local_test {
     }
 
     impl Arbitrary for GossipsubRpc {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
+        fn arbitrary(g: &mut Gen) -> Self {
             let mut rpc = empty_rpc();
 
-            for _ in 0..g.gen_range(0, 10) {
+            for _ in 0..g.gen_range(0..10u8) {
                 rpc.subscriptions.push(test_subscription());
             }
-            for _ in 0..g.gen_range(0, 10) {
+            for _ in 0..g.gen_range(0..10u8) {
                 rpc.messages.push(test_message());
             }
-            for _ in 0..g.gen_range(0, 10) {
+            for _ in 0..g.gen_range(0..10u8) {
                 rpc.control_msgs.push(test_control());
             }
             rpc
diff --git a/protocols/gossipsub/src/behaviour/tests.rs b/protocols/gossipsub/src/behaviour/tests.rs
index b4760b7208b..f405daa0a2e 100644
--- a/protocols/gossipsub/src/behaviour/tests.rs
+++ b/protocols/gossipsub/src/behaviour/tests.rs
@@ -3293,12 +3293,12 @@ mod tests {
         *seq += 1;
         RawGossipsubMessage {
             source: Some(PeerId::random()),
-            data: (0..rng.gen_range(10, 30))
+            data: (0..rng.gen_range(10..30))
                 .into_iter()
                 .map(|_| rng.gen())
                 .collect(),
             sequence_number: Some(*seq),
-            topic: topics[rng.gen_range(0, topics.len())].clone(),
+            topic: topics[rng.gen_range(0..topics.len())].clone(),
             signature: None,
             key: None,
             validated: true,
diff --git a/protocols/gossipsub/src/protocol.rs b/protocols/gossipsub/src/protocol.rs
index 0eb5f4ee56b..3695bcb9f97 100644
--- a/protocols/gossipsub/src/protocol.rs
+++ b/protocols/gossipsub/src/protocol.rs
@@ -572,13 +572,12 @@ mod tests {
     use crate::IdentTopic as Topic;
     use libp2p_core::identity::Keypair;
     use quickcheck::*;
-    use rand::Rng;
 
     #[derive(Clone, Debug)]
     struct Message(RawGossipsubMessage);
 
     impl Arbitrary for Message {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
+        fn arbitrary(g: &mut Gen) -> Self {
             let keypair = TestKeypair::arbitrary(g);
 
             // generate an arbitrary GossipsubMessage using the behaviour signing functionality
@@ -588,8 +587,8 @@ mod tests {
                 config,
             )
             .unwrap();
-            let data = (0..g.gen_range(10, 10024))
-                .map(|_| g.gen())
+            let data = (0..g.gen_range(10..10024u32))
+                .map(|_| u8::arbitrary(g))
                 .collect::<Vec<_>>();
             let topic_id = TopicId::arbitrary(g).0;
             Message(gs.build_raw_message(topic_id, data).unwrap())
@@ -600,9 +599,9 @@ mod tests {
     struct TopicId(TopicHash);
 
     impl Arbitrary for TopicId {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            let topic_string: String = (0..g.gen_range(20, 1024))
-                .map(|_| g.gen::<char>())
+        fn arbitrary(g: &mut Gen) -> Self {
+            let topic_string: String = (0..g.gen_range(20..1024u32))
+                .map(|_| char::arbitrary(g))
                 .collect::<String>()
                 .into();
             TopicId(Topic::new(topic_string).into())
@@ -614,8 +613,8 @@ mod tests {
 
     impl Arbitrary for TestKeypair {
         #[cfg(feature = "rsa")]
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            let keypair = if g.gen() {
+        fn arbitrary(g: &mut Gen) -> Self {
+            let keypair = if bool::arbitrary(g) {
                 // Small enough to be inlined.
                 Keypair::generate_ed25519()
             } else {
@@ -627,7 +626,7 @@ mod tests {
         }
 
         #[cfg(not(feature = "rsa"))]
-        fn arbitrary<G: Gen>(_g: &mut G) -> Self {
+        fn arbitrary(_g: &mut Gen) -> Self {
             // Small enough to be inlined.
             TestKeypair(Keypair::generate_ed25519())
         }
diff --git a/protocols/kad/CHANGELOG.md b/protocols/kad/CHANGELOG.md
index 2f41a093019..6ac2977d635 100644
--- a/protocols/kad/CHANGELOG.md
+++ b/protocols/kad/CHANGELOG.md
@@ -3,7 +3,10 @@
 - Remove deprecated `set_protocol_name()` from `KademliaConfig` & `KademliaProtocolConfig`.
   Use `set_protocol_names()` instead. See [PR 2866].
 
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
 [PR 2866]: https://github.com/libp2p/rust-libp2p/pull/2866
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
 
 # 0.40.0
 
diff --git a/protocols/kad/Cargo.toml b/protocols/kad/Cargo.toml
index c01f64f387a..aa9efc6e0da 100644
--- a/protocols/kad/Cargo.toml
+++ b/protocols/kad/Cargo.toml
@@ -21,7 +21,7 @@ log = "0.4"
 libp2p-core = { version = "0.36.0", path = "../../core", default-features = false }
 libp2p-swarm = { version = "0.39.0", path = "../../swarm" }
 prost = "0.11"
-rand = "0.7.2"
+rand = "0.8"
 sha2 = "0.10.0"
 smallvec = "1.6.1"
 uint = "0.9"
@@ -36,7 +36,7 @@ thiserror = "1"
 env_logger = "0.9.0"
 futures-timer = "3.0"
 libp2p = { path = "../../", default-features = false, features = ["noise", "yamux"] }
-quickcheck = "0.9.0"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 
 [build-dependencies]
 prost-build = "0.11"
diff --git a/protocols/kad/src/behaviour/test.rs b/protocols/kad/src/behaviour/test.rs
index b9d2a896d4c..a30ff2d4311 100644
--- a/protocols/kad/src/behaviour/test.rs
+++ b/protocols/kad/src/behaviour/test.rs
@@ -144,8 +144,9 @@ fn random_multihash() -> Multihash {
 struct Seed([u8; 32]);
 
 impl Arbitrary for Seed {
-    fn arbitrary<G: Gen>(g: &mut G) -> Seed {
-        Seed(g.gen())
+    fn arbitrary(g: &mut Gen) -> Seed {
+        let seed = core::array::from_fn(|_| u8::arbitrary(g));
+        Seed(seed)
     }
 }
 
@@ -154,14 +155,14 @@ fn bootstrap() {
     fn prop(seed: Seed) {
         let mut rng = StdRng::from_seed(seed.0);
 
-        let num_total = rng.gen_range(2, 20);
+        let num_total = rng.gen_range(2..20);
         // When looking for the closest node to a key, Kademlia considers
         // K_VALUE nodes to query at initialization. If `num_group` is larger
         // than K_VALUE the remaining locally known nodes will not be
         // considered. Given that no other node is aware of them, they would be
         // lost entirely. To prevent the above restrict `num_group` to be equal
         // or smaller than K_VALUE.
-        let num_group = rng.gen_range(1, (num_total % K_VALUE.get()) + 2);
+        let num_group = rng.gen_range(1..(num_total % K_VALUE.get()) + 2);
 
         let mut cfg = KademliaConfig::default();
         if rng.gen() {
@@ -241,7 +242,7 @@ fn query_iter() {
     }
 
     fn run(rng: &mut impl Rng) {
-        let num_total = rng.gen_range(2, 20);
+        let num_total = rng.gen_range(2..20);
         let mut swarms = build_connected_nodes(num_total, 1)
             .into_iter()
             .map(|(_a, s)| s)
@@ -489,7 +490,7 @@ fn put_record() {
     fn prop(records: Vec<Record>, seed: Seed, filter_records: bool, drop_records: bool) {
         let mut rng = StdRng::from_seed(seed.0);
         let replication_factor =
-            NonZeroUsize::new(rng.gen_range(1, (K_VALUE.get() / 2) + 1)).unwrap();
+            NonZeroUsize::new(rng.gen_range(1..(K_VALUE.get() / 2) + 1)).unwrap();
         // At least 4 nodes, 1 under test + 3 bootnodes.
         let num_total = usize::max(4, replication_factor.get() * 2);
 
@@ -853,7 +854,7 @@ fn add_provider() {
     fn prop(keys: Vec<record::Key>, seed: Seed) {
         let mut rng = StdRng::from_seed(seed.0);
         let replication_factor =
-            NonZeroUsize::new(rng.gen_range(1, (K_VALUE.get() / 2) + 1)).unwrap();
+            NonZeroUsize::new(rng.gen_range(1..(K_VALUE.get() / 2) + 1)).unwrap();
         // At least 4 nodes, 1 under test + 3 bootnodes.
         let num_total = usize::max(4, replication_factor.get() * 2);
 
diff --git a/protocols/kad/src/jobs.rs b/protocols/kad/src/jobs.rs
index 7e8ca628ce6..b0fbe16aeb2 100644
--- a/protocols/kad/src/jobs.rs
+++ b/protocols/kad/src/jobs.rs
@@ -335,15 +335,15 @@ mod tests {
     fn rand_put_record_job() -> PutRecordJob {
         let mut rng = rand::thread_rng();
         let id = PeerId::random();
-        let replicate_interval = Duration::from_secs(rng.gen_range(1, 60));
-        let publish_interval = Some(replicate_interval * rng.gen_range(1, 10));
-        let record_ttl = Some(Duration::from_secs(rng.gen_range(1, 600)));
+        let replicate_interval = Duration::from_secs(rng.gen_range(1..60));
+        let publish_interval = Some(replicate_interval * rng.gen_range(1..10));
+        let record_ttl = Some(Duration::from_secs(rng.gen_range(1..600)));
         PutRecordJob::new(id.clone(), replicate_interval, publish_interval, record_ttl)
     }
 
     fn rand_add_provider_job() -> AddProviderJob {
         let mut rng = rand::thread_rng();
-        let interval = Duration::from_secs(rng.gen_range(1, 60));
+        let interval = Duration::from_secs(rng.gen_range(1..60));
         AddProviderJob::new(interval)
     }
 
diff --git a/protocols/kad/src/kbucket.rs b/protocols/kad/src/kbucket.rs
index d1c8622dc27..82b88b2936e 100644
--- a/protocols/kad/src/kbucket.rs
+++ b/protocols/kad/src/kbucket.rs
@@ -138,7 +138,7 @@ impl BucketIndex {
         let rem = (self.0 % 8) as u32;
         let lower = usize::pow(2, rem);
         let upper = usize::pow(2, rem + 1);
-        bytes[31 - quot] = rng.gen_range(lower, upper) as u8;
+        bytes[31 - quot] = rng.gen_range(lower..upper) as u8;
         Distance(U256::from(bytes))
     }
 }
@@ -524,22 +524,21 @@ mod tests {
     use super::*;
     use libp2p_core::PeerId;
     use quickcheck::*;
-    use rand::Rng;
 
     type TestTable = KBucketsTable<KeyBytes, ()>;
 
     impl Arbitrary for TestTable {
-        fn arbitrary<G: Gen>(g: &mut G) -> TestTable {
+        fn arbitrary(g: &mut Gen) -> TestTable {
             let local_key = Key::from(PeerId::random());
-            let timeout = Duration::from_secs(g.gen_range(1, 360));
+            let timeout = Duration::from_secs(g.gen_range(1..360));
             let mut table = TestTable::new(local_key.clone().into(), timeout);
-            let mut num_total = g.gen_range(0, 100);
+            let mut num_total = g.gen_range(0..100);
             for (i, b) in &mut table.buckets.iter_mut().enumerate().rev() {
                 let ix = BucketIndex(i);
-                let num = g.gen_range(0, usize::min(K_VALUE.get(), num_total) + 1);
+                let num = g.gen_range(0..usize::min(K_VALUE.get(), num_total) + 1);
                 num_total -= num;
                 for _ in 0..num {
-                    let distance = ix.rand_distance(g);
+                    let distance = ix.rand_distance(&mut rand::thread_rng());
                     let key = local_key.for_distance(distance);
                     let node = Node {
                         key: key.clone(),
@@ -590,8 +589,15 @@ mod tests {
             assert!(bucket_ref.contains(&min));
             assert!(bucket_ref.contains(&max));
 
-            assert!(!bucket_ref.contains(&Distance(min.0 - 1)));
-            assert!(!bucket_ref.contains(&Distance(max.0 + 1)));
+            if min != Distance(0.into()) {
+                // ^ avoid underflow
+                assert!(!bucket_ref.contains(&Distance(min.0 - 1)));
+            }
+
+            if max != Distance(U256::max_value()) {
+                // ^ avoid overflow
+                assert!(!bucket_ref.contains(&Distance(max.0 + 1)));
+            }
         }
 
         quickcheck(prop as fn(_));
@@ -605,7 +611,7 @@ mod tests {
             let b = U256::from(2);
             let e = U256::from(ix);
             let lower = b.pow(e);
-            let upper = b.pow(e + U256::from(1)) - U256::from(1);
+            let upper = b.checked_pow(e + U256::from(1)).unwrap_or(U256::MAX) - U256::from(1);
             lower <= n && n <= upper
         }
         quickcheck(prop as fn(_) -> _);
diff --git a/protocols/kad/src/kbucket/bucket.rs b/protocols/kad/src/kbucket/bucket.rs
index 0e3ad368863..9a6df073c56 100644
--- a/protocols/kad/src/kbucket/bucket.rs
+++ b/protocols/kad/src/kbucket/bucket.rs
@@ -437,14 +437,13 @@ mod tests {
     use super::*;
     use libp2p_core::PeerId;
     use quickcheck::*;
-    use rand::Rng;
     use std::collections::VecDeque;
 
     impl Arbitrary for KBucket<Key<PeerId>, ()> {
-        fn arbitrary<G: Gen>(g: &mut G) -> KBucket<Key<PeerId>, ()> {
-            let timeout = Duration::from_secs(g.gen_range(1, g.size() as u64));
+        fn arbitrary(g: &mut Gen) -> KBucket<Key<PeerId>, ()> {
+            let timeout = Duration::from_secs(g.gen_range(1..g.size()) as u64);
             let mut bucket = KBucket::<Key<PeerId>, ()>::new(timeout);
-            let num_nodes = g.gen_range(1, K_VALUE.get() + 1);
+            let num_nodes = g.gen_range(1..K_VALUE.get() + 1);
             for _ in 0..num_nodes {
                 let key = Key::from(PeerId::random());
                 let node = Node {
@@ -462,8 +461,8 @@ mod tests {
     }
 
     impl Arbitrary for NodeStatus {
-        fn arbitrary<G: Gen>(g: &mut G) -> NodeStatus {
-            if g.gen() {
+        fn arbitrary(g: &mut Gen) -> NodeStatus {
+            if bool::arbitrary(g) {
                 NodeStatus::Connected
             } else {
                 NodeStatus::Disconnected
@@ -472,8 +471,8 @@ mod tests {
     }
 
     impl Arbitrary for Position {
-        fn arbitrary<G: Gen>(g: &mut G) -> Position {
-            Position(g.gen_range(0, K_VALUE.get()))
+        fn arbitrary(g: &mut Gen) -> Position {
+            Position(g.gen_range(0..K_VALUE.get()))
         }
     }
 
diff --git a/protocols/kad/src/kbucket/key.rs b/protocols/kad/src/kbucket/key.rs
index 9133757a0ff..00a15765de4 100644
--- a/protocols/kad/src/kbucket/key.rs
+++ b/protocols/kad/src/kbucket/key.rs
@@ -197,17 +197,16 @@ mod tests {
     use super::*;
     use libp2p_core::multihash::Code;
     use quickcheck::*;
-    use rand::Rng;
 
     impl Arbitrary for Key<PeerId> {
-        fn arbitrary<G: Gen>(_: &mut G) -> Key<PeerId> {
+        fn arbitrary(_: &mut Gen) -> Key<PeerId> {
             Key::from(PeerId::random())
         }
     }
 
     impl Arbitrary for Key<Multihash> {
-        fn arbitrary<G: Gen>(_: &mut G) -> Key<Multihash> {
-            let hash = rand::thread_rng().gen::<[u8; 32]>();
+        fn arbitrary(g: &mut Gen) -> Key<Multihash> {
+            let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
             Key::from(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
         }
     }
diff --git a/protocols/kad/src/query/peers/closest.rs b/protocols/kad/src/query/peers/closest.rs
index 2b3cb124274..87d452e8e40 100644
--- a/protocols/kad/src/query/peers/closest.rs
+++ b/protocols/kad/src/query/peers/closest.rs
@@ -500,16 +500,29 @@ mod tests {
             .all(|w| w[0].distance(&target) < w[1].distance(&target))
     }
 
+    #[derive(Clone, Debug)]
+    struct ArbitraryPeerId(PeerId);
+
+    impl Arbitrary for ArbitraryPeerId {
+        fn arbitrary(g: &mut Gen) -> ArbitraryPeerId {
+            let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
+            let peer_id =
+                PeerId::from_multihash(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
+                    .unwrap();
+            ArbitraryPeerId(peer_id)
+        }
+    }
+
     impl Arbitrary for ClosestPeersIter {
-        fn arbitrary<G: Gen>(g: &mut G) -> ClosestPeersIter {
-            let known_closest_peers = random_peers(g.gen_range(1, 60), g)
-                .into_iter()
-                .map(Key::from);
-            let target = Key::from(Into::<Multihash>::into(PeerId::random()));
+        fn arbitrary(g: &mut Gen) -> ClosestPeersIter {
+            let known_closest_peers = (0..g.gen_range(1..60u8))
+                .map(|_| Key::from(ArbitraryPeerId::arbitrary(g).0))
+                .collect::<Vec<_>>();
+            let target = Key::from(ArbitraryPeerId::arbitrary(g).0);
             let config = ClosestPeersIterConfig {
-                parallelism: NonZeroUsize::new(g.gen_range(1, 10)).unwrap(),
-                num_results: NonZeroUsize::new(g.gen_range(1, 25)).unwrap(),
-                peer_timeout: Duration::from_secs(g.gen_range(10, 30)),
+                parallelism: NonZeroUsize::new(g.gen_range(1..10)).unwrap(),
+                num_results: NonZeroUsize::new(g.gen_range(1..25)).unwrap(),
+                peer_timeout: Duration::from_secs(g.gen_range(10..30)),
             };
             ClosestPeersIter::with_config(config, target, known_closest_peers)
         }
@@ -519,8 +532,9 @@ mod tests {
     struct Seed([u8; 32]);
 
     impl Arbitrary for Seed {
-        fn arbitrary<G: Gen>(g: &mut G) -> Seed {
-            Seed(g.gen())
+        fn arbitrary(g: &mut Gen) -> Seed {
+            let seed = core::array::from_fn(|_| u8::arbitrary(g));
+            Seed(seed)
         }
     }
 
@@ -612,7 +626,7 @@ mod tests {
                 // peers or an error, thus finishing the "in-flight requests".
                 for (i, k) in expected.iter().enumerate() {
                     if rng.gen_bool(0.75) {
-                        let num_closer = rng.gen_range(0, iter.config.num_results.get() + 1);
+                        let num_closer = rng.gen_range(0..iter.config.num_results.get() + 1);
                         let closer_peers = random_peers(num_closer, &mut rng);
                         remaining.extend(closer_peers.iter().cloned().map(Key::from));
                         iter.on_success(k.preimage(), closer_peers);
@@ -668,11 +682,10 @@ mod tests {
 
     #[test]
     fn no_duplicates() {
-        fn prop(mut iter: ClosestPeersIter, seed: Seed) -> bool {
+        fn prop(mut iter: ClosestPeersIter, closer: ArbitraryPeerId) -> bool {
             let now = Instant::now();
-            let mut rng = StdRng::from_seed(seed.0);
 
-            let closer = random_peers(1, &mut rng);
+            let closer = vec![closer.0];
 
             // A first peer reports a "closer" peer.
             let peer1 = match iter.next(now) {
diff --git a/protocols/kad/src/query/peers/closest/disjoint.rs b/protocols/kad/src/query/peers/closest/disjoint.rs
index af91b8c1f0b..df7ab70bedc 100644
--- a/protocols/kad/src/query/peers/closest/disjoint.rs
+++ b/protocols/kad/src/query/peers/closest/disjoint.rs
@@ -447,21 +447,20 @@ mod tests {
     use crate::K_VALUE;
     use libp2p_core::multihash::{Code, Multihash};
     use quickcheck::*;
-    use rand::{seq::SliceRandom, Rng};
     use std::collections::HashSet;
     use std::iter;
 
     impl Arbitrary for ResultIter<std::vec::IntoIter<Key<PeerId>>> {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
+        fn arbitrary(g: &mut Gen) -> Self {
             let target = Target::arbitrary(g).0;
-            let num_closest_iters = g.gen_range(0, 20 + 1);
-            let peers = random_peers(g.gen_range(0, 20 * num_closest_iters + 1), g);
+            let num_closest_iters = g.gen_range(0..20 + 1);
+            let peers = random_peers(g.gen_range(0..20 * num_closest_iters + 1), g);
 
             let iters: Vec<_> = (0..num_closest_iters)
                 .map(|_| {
-                    let num_peers = g.gen_range(0, 20 + 1);
-                    let mut peers = peers
-                        .choose_multiple(g, num_peers)
+                    let num_peers = g.gen_range(0..20 + 1);
+                    let mut peers = g
+                        .choose_multiple(&peers, num_peers)
                         .cloned()
                         .map(Key::from)
                         .collect::<Vec<_>>();
@@ -532,24 +531,31 @@ mod tests {
         }
     }
 
+    #[derive(Clone, Debug)]
+    struct ArbitraryPeerId(PeerId);
+
+    impl Arbitrary for ArbitraryPeerId {
+        fn arbitrary(g: &mut Gen) -> ArbitraryPeerId {
+            let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
+            let peer_id =
+                PeerId::from_multihash(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
+                    .unwrap();
+            ArbitraryPeerId(peer_id)
+        }
+    }
+
     #[derive(Clone, Debug)]
     struct Target(KeyBytes);
 
     impl Arbitrary for Target {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            Target(Key::from(random_peers(1, g).pop().unwrap()).into())
+        fn arbitrary(g: &mut Gen) -> Self {
+            let peer_id = ArbitraryPeerId::arbitrary(g).0;
+            Target(Key::from(peer_id).into())
         }
     }
 
-    fn random_peers<R: Rng>(n: usize, g: &mut R) -> Vec<PeerId> {
-        (0..n)
-            .map(|_| {
-                PeerId::from_multihash(
-                    Multihash::wrap(Code::Sha2_256.into(), &g.gen::<[u8; 32]>()).unwrap(),
-                )
-                .unwrap()
-            })
-            .collect()
+    fn random_peers(n: usize, g: &mut Gen) -> Vec<PeerId> {
+        (0..n).map(|_| ArbitraryPeerId::arbitrary(g).0).collect()
     }
 
     #[test]
@@ -586,8 +592,8 @@ mod tests {
     struct Parallelism(NonZeroUsize);
 
     impl Arbitrary for Parallelism {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            Parallelism(NonZeroUsize::new(g.gen_range(1, 10)).unwrap())
+        fn arbitrary(g: &mut Gen) -> Self {
+            Parallelism(NonZeroUsize::new(g.gen_range(1..10)).unwrap())
         }
     }
 
@@ -595,13 +601,13 @@ mod tests {
     struct NumResults(NonZeroUsize);
 
     impl Arbitrary for NumResults {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            NumResults(NonZeroUsize::new(g.gen_range(1, K_VALUE.get())).unwrap())
+        fn arbitrary(g: &mut Gen) -> Self {
+            NumResults(NonZeroUsize::new(g.gen_range(1..K_VALUE.get())).unwrap())
         }
     }
 
     impl Arbitrary for ClosestPeersIterConfig {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
+        fn arbitrary(g: &mut Gen) -> Self {
             ClosestPeersIterConfig {
                 parallelism: Parallelism::arbitrary(g).0,
                 num_results: NumResults::arbitrary(g).0,
@@ -614,10 +620,10 @@ mod tests {
     struct PeerVec(pub Vec<Key<PeerId>>);
 
     impl Arbitrary for PeerVec {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
+        fn arbitrary(g: &mut Gen) -> Self {
             PeerVec(
-                (0..g.gen_range(1, 60))
-                    .map(|_| PeerId::random())
+                (0..g.gen_range(1..60u8))
+                    .map(|_| ArbitraryPeerId::arbitrary(g).0)
                     .map(Key::from)
                     .collect(),
             )
@@ -743,8 +749,8 @@ mod tests {
     }
 
     impl Arbitrary for Graph {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            let mut peer_ids = random_peers(g.gen_range(K_VALUE.get(), 200), g)
+        fn arbitrary(g: &mut Gen) -> Self {
+            let mut peer_ids = random_peers(g.gen_range(K_VALUE.get()..200), g)
                 .into_iter()
                 .map(|peer_id| (peer_id.clone(), Key::from(peer_id)))
                 .collect::<Vec<_>>();
@@ -773,11 +779,11 @@ mod tests {
 
             // Make each peer aware of a random set of other peers within the graph.
             for (peer_id, peer) in peers.iter_mut() {
-                peer_ids.shuffle(g);
+                g.shuffle(&mut peer_ids);
 
-                let num_peers = g.gen_range(K_VALUE.get(), peer_ids.len() + 1);
-                let mut random_peer_ids = peer_ids
-                    .choose_multiple(g, num_peers)
+                let num_peers = g.gen_range(K_VALUE.get()..peer_ids.len() + 1);
+                let mut random_peer_ids = g
+                    .choose_multiple(&peer_ids, num_peers)
                     // Make sure not to include itself.
                     .filter(|(id, _)| peer_id != id)
                     .cloned()
diff --git a/protocols/kad/src/record.rs b/protocols/kad/src/record.rs
index 2a40292c243..0da60e704e9 100644
--- a/protocols/kad/src/record.rs
+++ b/protocols/kad/src/record.rs
@@ -162,28 +162,27 @@ mod tests {
     use super::*;
     use libp2p_core::multihash::Code;
     use quickcheck::*;
-    use rand::Rng;
     use std::time::Duration;
 
     impl Arbitrary for Key {
-        fn arbitrary<G: Gen>(_: &mut G) -> Key {
-            let hash = rand::thread_rng().gen::<[u8; 32]>();
+        fn arbitrary(g: &mut Gen) -> Key {
+            let hash: [u8; 32] = core::array::from_fn(|_| u8::arbitrary(g));
             Key::from(Multihash::wrap(Code::Sha2_256.into(), &hash).unwrap())
         }
     }
 
     impl Arbitrary for Record {
-        fn arbitrary<G: Gen>(g: &mut G) -> Record {
+        fn arbitrary(g: &mut Gen) -> Record {
             Record {
                 key: Key::arbitrary(g),
                 value: Vec::arbitrary(g),
-                publisher: if g.gen() {
+                publisher: if bool::arbitrary(g) {
                     Some(PeerId::random())
                 } else {
                     None
                 },
-                expires: if g.gen() {
-                    Some(Instant::now() + Duration::from_secs(g.gen_range(0, 60)))
+                expires: if bool::arbitrary(g) {
+                    Some(Instant::now() + Duration::from_secs(g.gen_range(0..60)))
                 } else {
                     None
                 },
@@ -192,12 +191,12 @@ mod tests {
     }
 
     impl Arbitrary for ProviderRecord {
-        fn arbitrary<G: Gen>(g: &mut G) -> ProviderRecord {
+        fn arbitrary(g: &mut Gen) -> ProviderRecord {
             ProviderRecord {
                 key: Key::arbitrary(g),
                 provider: PeerId::random(),
-                expires: if g.gen() {
-                    Some(Instant::now() + Duration::from_secs(g.gen_range(0, 60)))
+                expires: if bool::arbitrary(g) {
+                    Some(Instant::now() + Duration::from_secs(g.gen_range(0..60)))
                 } else {
                     None
                 },
diff --git a/protocols/ping/CHANGELOG.md b/protocols/ping/CHANGELOG.md
index b1037ac1ef7..f7932c38b4f 100644
--- a/protocols/ping/CHANGELOG.md
+++ b/protocols/ping/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.39.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.39.0
 
 - Update to `libp2p-swarm` `v0.39.0`.
diff --git a/protocols/ping/Cargo.toml b/protocols/ping/Cargo.toml
index 28eb91bab9b..9f19af8d26e 100644
--- a/protocols/ping/Cargo.toml
+++ b/protocols/ping/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-ping"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Ping protocol for libp2p"
-version = "0.39.0"
+version = "0.39.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -17,10 +17,10 @@ instant = "0.1.11"
 libp2p-core = { version = "0.36.0", path = "../../core", default-features = false }
 libp2p-swarm = { version = "0.39.0", path = "../../swarm" }
 log = "0.4.1"
-rand = "0.7.2"
+rand = "0.8"
 void = "1.0"
 
 [dev-dependencies]
 async-std = "1.6.2"
 libp2p = { path = "../../", default-features = false, features = ["tcp-async-io", "noise", "mplex", "yamux", "ping"] }
-quickcheck = "0.9.0"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
diff --git a/protocols/ping/tests/ping.rs b/protocols/ping/tests/ping.rs
index aac7614d4a4..cdf68466e64 100644
--- a/protocols/ping/tests/ping.rs
+++ b/protocols/ping/tests/ping.rs
@@ -34,7 +34,6 @@ use libp2p::swarm::{DummyBehaviour, KeepAlive, Swarm, SwarmEvent};
 use libp2p::tcp::{GenTcpConfig, TcpTransport};
 use libp2p::yamux;
 use quickcheck::*;
-use rand::prelude::*;
 use std::{num::NonZeroU8, time::Duration};
 
 #[test]
@@ -263,7 +262,7 @@ enum MuxerChoice {
 }
 
 impl Arbitrary for MuxerChoice {
-    fn arbitrary<G: Gen>(g: &mut G) -> MuxerChoice {
-        *[MuxerChoice::Mplex, MuxerChoice::Yamux].choose(g).unwrap()
+    fn arbitrary(g: &mut Gen) -> MuxerChoice {
+        *g.choose(&[MuxerChoice::Mplex, MuxerChoice::Yamux]).unwrap()
     }
 }
diff --git a/protocols/relay/Cargo.toml b/protocols/relay/Cargo.toml
index 9e564825ccf..d7a772a18e0 100644
--- a/protocols/relay/Cargo.toml
+++ b/protocols/relay/Cargo.toml
@@ -35,5 +35,5 @@ prost-build = "0.11"
 [dev-dependencies]
 env_logger = "0.9.0"
 libp2p = { path = "../..", default-features = false, features = ["identify", "kad", "ping", "plaintext", "tcp-async-io", "relay", "noise", "yamux"] }
-quickcheck = "1"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 clap = {version = "3.1.6", features = ["derive"]}
diff --git a/protocols/request-response/CHANGELOG.md b/protocols/request-response/CHANGELOG.md
index 2e7dd0f84d4..aabb121ad69 100644
--- a/protocols/request-response/CHANGELOG.md
+++ b/protocols/request-response/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.21.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.21.0
 
 - Update to `libp2p-swarm` `v0.39.0`.
diff --git a/protocols/request-response/Cargo.toml b/protocols/request-response/Cargo.toml
index e6e2c400dac..3b0b23bb011 100644
--- a/protocols/request-response/Cargo.toml
+++ b/protocols/request-response/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-request-response"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Generic Request/Response Protocols"
-version = "0.21.0"
+version = "0.21.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -18,7 +18,7 @@ instant = "0.1.11"
 libp2p-core = { version = "0.36.0", path = "../../core", default-features = false  }
 libp2p-swarm = { version = "0.39.0", path = "../../swarm" }
 log = "0.4.11"
-rand = "0.7"
+rand = "0.8"
 smallvec = "1.6.1"
 unsigned-varint = { version = "0.7", features = ["std", "futures"] }
 
@@ -26,4 +26,4 @@ unsigned-varint = { version = "0.7", features = ["std", "futures"] }
 async-std = "1.6.2"
 env_logger = "0.9.0"
 libp2p = { path = "../../", default-features = false, features = ["tcp-async-io", "noise", "yamux", "request-response"] }
-rand = "0.7"
+rand = "0.8"
diff --git a/protocols/request-response/tests/ping.rs b/protocols/request-response/tests/ping.rs
index ef35361369e..a333ef9111a 100644
--- a/protocols/request-response/tests/ping.rs
+++ b/protocols/request-response/tests/ping.rs
@@ -127,7 +127,7 @@ fn ping_protocol() {
         }
     };
 
-    let num_pings: u8 = rand::thread_rng().gen_range(1, 100);
+    let num_pings: u8 = rand::thread_rng().gen_range(1..100);
 
     let peer2 = async move {
         let mut count = 0;
diff --git a/swarm/CHANGELOG.md b/swarm/CHANGELOG.md
index 3937c265d31..ff8d3a27d84 100644
--- a/swarm/CHANGELOG.md
+++ b/swarm/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.39.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.39.0
 
 - Remove deprecated `NetworkBehaviourEventProcess`. See [libp2p-swarm v0.38.0 changelog entry] for
diff --git a/swarm/Cargo.toml b/swarm/Cargo.toml
index fe310b5e072..09137616935 100644
--- a/swarm/Cargo.toml
+++ b/swarm/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-swarm"
 edition = "2021"
 rust-version = "1.56.1"
 description = "The libp2p swarm"
-version = "0.39.0"
+version = "0.39.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -19,7 +19,7 @@ instant = "0.1.11"
 libp2p-core = { version = "0.36.0", path = "../core", default-features = false }
 log = "0.4"
 pin-project = "1.0.0"
-rand = "0.7"
+rand = "0.8"
 smallvec = "1.6.1"
 thiserror = "1.0"
 void = "1"
@@ -28,5 +28,4 @@ void = "1"
 async-std = { version = "1.6.2", features = ["attributes"] }
 env_logger = "0.9"
 libp2p = { path = "../", default-features = false, features = ["plaintext", "identify", "ping", "noise", "yamux", "mplex", "tcp-async-io"] }
-quickcheck = "0.9.0"
-rand = "0.7.2"
+quickcheck = { package = "quickcheck-ext", path = "../misc/quickcheck-ext" }
diff --git a/swarm/src/handler/multi.rs b/swarm/src/handler/multi.rs
index f7e4d7ed1b4..07c1168b132 100644
--- a/swarm/src/handler/multi.rs
+++ b/swarm/src/handler/multi.rs
@@ -295,7 +295,7 @@ where
         }
 
         // Not always polling handlers in the same order should give anyone the chance to make progress.
-        let pos = rand::thread_rng().gen_range(0, self.handlers.len());
+        let pos = rand::thread_rng().gen_range(0..self.handlers.len());
 
         for (k, h) in self.handlers.iter_mut().skip(pos) {
             if let Poll::Ready(e) = h.poll(cx) {
diff --git a/swarm/src/lib.rs b/swarm/src/lib.rs
index 7faaa43b44d..3cf9d24326f 100644
--- a/swarm/src/lib.rs
+++ b/swarm/src/lib.rs
@@ -1623,8 +1623,7 @@ mod tests {
     use libp2p_core::multiaddr::multiaddr;
     use libp2p_core::transport::TransportEvent;
     use libp2p_core::Endpoint;
-    use quickcheck::{quickcheck, Arbitrary, Gen, QuickCheck};
-    use rand::Rng;
+    use quickcheck::*;
 
     // Test execution state.
     // Connection => Disconnecting => Connecting.
@@ -2047,8 +2046,8 @@ mod tests {
         struct DialConcurrencyFactor(NonZeroU8);
 
         impl Arbitrary for DialConcurrencyFactor {
-            fn arbitrary<G: Gen>(g: &mut G) -> Self {
-                Self(NonZeroU8::new(g.gen_range(1, 11)).unwrap())
+            fn arbitrary(g: &mut Gen) -> Self {
+                Self(NonZeroU8::new(g.gen_range(1..11)).unwrap())
             }
         }
 
@@ -2121,7 +2120,7 @@ mod tests {
     fn max_outgoing() {
         use rand::Rng;
 
-        let outgoing_limit = rand::thread_rng().gen_range(1, 10);
+        let outgoing_limit = rand::thread_rng().gen_range(1..10);
 
         let limits = ConnectionLimits::default().with_max_pending_outgoing(Some(outgoing_limit));
         let mut network = new_test_swarm::<_, ()>(DummyConnectionHandler {
@@ -2169,14 +2168,12 @@ mod tests {
 
     #[test]
     fn max_established_incoming() {
-        use rand::Rng;
-
         #[derive(Debug, Clone)]
         struct Limit(u32);
 
         impl Arbitrary for Limit {
-            fn arbitrary<G: Gen>(g: &mut G) -> Self {
-                Self(g.gen_range(1, 10))
+            fn arbitrary(g: &mut Gen) -> Self {
+                Self(g.gen_range(1..10))
             }
         }
 
diff --git a/swarm/src/registry.rs b/swarm/src/registry.rs
index 76892edf981..f0a6153ec86 100644
--- a/swarm/src/registry.rs
+++ b/swarm/src/registry.rs
@@ -338,23 +338,22 @@ mod tests {
     use super::*;
     use libp2p_core::multiaddr::{Multiaddr, Protocol};
     use quickcheck::*;
-    use rand::Rng;
     use std::num::{NonZeroU8, NonZeroUsize};
 
     impl Arbitrary for AddressScore {
-        fn arbitrary<G: Gen>(g: &mut G) -> AddressScore {
-            if g.gen_range(0, 10) == 0 {
+        fn arbitrary(g: &mut Gen) -> AddressScore {
+            if g.gen_range(0..10u8) == 0 {
                 // ~10% "Infinitely" scored addresses
                 AddressScore::Infinite
             } else {
-                AddressScore::Finite(g.gen())
+                AddressScore::Finite(Arbitrary::arbitrary(g))
             }
         }
     }
 
     impl Arbitrary for AddressRecord {
-        fn arbitrary<G: Gen>(g: &mut G) -> Self {
-            let addr = Protocol::Tcp(g.gen::<u16>() % 256).into();
+        fn arbitrary(g: &mut Gen) -> Self {
+            let addr = Protocol::Tcp(g.gen_range(0..256)).into();
             let score = AddressScore::arbitrary(g);
             AddressRecord::new(addr, score)
         }
@@ -381,7 +380,7 @@ mod tests {
     #[test]
     fn score_retention() {
         fn prop(first: AddressRecord, other: AddressRecord) -> TestResult {
-            if first.addr == other.addr {
+            if first.addr == other.addr || first.score.is_zero() {
                 return TestResult::discard();
             }
 
@@ -412,6 +411,33 @@ mod tests {
         quickcheck(prop as fn(_, _) -> _);
     }
 
+    #[test]
+    fn score_retention_finite_0() {
+        let first = {
+            let addr = Protocol::Tcp(42).into();
+            let score = AddressScore::Finite(0);
+            AddressRecord::new(addr, score)
+        };
+        let other = {
+            let addr = Protocol::Udp(42).into();
+            let score = AddressScore::Finite(42);
+            AddressRecord::new(addr, score)
+        };
+
+        let mut addresses = Addresses::default();
+
+        // Add the first address.
+        addresses.add(first.addr.clone(), first.score);
+        assert!(addresses.iter().any(|a| &a.addr == &first.addr));
+
+        // Add another address so the first will address be purged,
+        // because its score is finite(0)
+        addresses.add(other.addr.clone(), other.score);
+
+        assert!(addresses.iter().any(|a| &a.addr == &other.addr));
+        assert!(!addresses.iter().any(|a| &a.addr == &first.addr));
+    }
+
     #[test]
     fn finitely_scored_address_limit() {
         fn prop(reports: Vec<AddressRecord>, limit: NonZeroU8) {
diff --git a/transports/deflate/Cargo.toml b/transports/deflate/Cargo.toml
index 298924c6caf..0050d9f148d 100644
--- a/transports/deflate/Cargo.toml
+++ b/transports/deflate/Cargo.toml
@@ -18,5 +18,5 @@ flate2 = "1.0"
 [dev-dependencies]
 async-std = "1.6.2"
 libp2p = { path = "../../", default-features = false, features = ["tcp-async-io", "deflate"] }
-quickcheck = "0.9"
-rand = "0.7"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
+rand = "0.8"
diff --git a/transports/deflate/tests/test.rs b/transports/deflate/tests/test.rs
index 9f661f9c8c5..726e562d8a2 100644
--- a/transports/deflate/tests/test.rs
+++ b/transports/deflate/tests/test.rs
@@ -22,7 +22,8 @@ use futures::{future, prelude::*};
 use libp2p::core::{transport::Transport, upgrade};
 use libp2p::deflate::DeflateConfig;
 use libp2p::tcp::TcpTransport;
-use quickcheck::{QuickCheck, RngCore, TestResult};
+use quickcheck::{QuickCheck, TestResult};
+use rand::RngCore;
 
 #[test]
 fn deflate() {
diff --git a/transports/noise/Cargo.toml b/transports/noise/Cargo.toml
index 8cd9db698b8..f886315236a 100644
--- a/transports/noise/Cargo.toml
+++ b/transports/noise/Cargo.toml
@@ -32,7 +32,7 @@ snow = { version = "0.9.0", features = ["default-resolver"], default-features =
 async-io = "1.2.0"
 env_logger = "0.9.0"
 libp2p = { path = "../../", default-features = false, features = ["tcp-async-io", "noise"] }
-quickcheck = "0.9.0"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
 libsodium-sys-stable = { version = "1.19.22", features = ["fetch-latest"] }
 ed25519-compact = "1.0.11"
 
diff --git a/transports/noise/tests/smoke.rs b/transports/noise/tests/smoke.rs
index a53ddaca7f5..16dcf4383d1 100644
--- a/transports/noise/tests/smoke.rs
+++ b/transports/noise/tests/smoke.rs
@@ -32,7 +32,7 @@ use libp2p::noise::{
 };
 use libp2p::tcp::TcpTransport;
 use log::info;
-use quickcheck::QuickCheck;
+use quickcheck::*;
 use std::{convert::TryInto, io, net::TcpStream};
 
 #[allow(dead_code)]
@@ -324,11 +324,13 @@ fn expect_identity<C>(
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct Message(Vec<u8>);
 
-impl quickcheck::Arbitrary for Message {
-    fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self {
-        let s = 1 + g.next_u32() % (128 * 1024);
-        let mut v = vec![0; s.try_into().unwrap()];
-        g.fill_bytes(&mut v);
+impl Arbitrary for Message {
+    fn arbitrary(g: &mut Gen) -> Self {
+        let s = g.gen_range(1..128 * 1024);
+        let mut v = vec![0; s];
+        for b in &mut v {
+            *b = u8::arbitrary(g);
+        }
         Message(v)
     }
 }
diff --git a/transports/plaintext/Cargo.toml b/transports/plaintext/Cargo.toml
index f250c2a4287..557ffa3123a 100644
--- a/transports/plaintext/Cargo.toml
+++ b/transports/plaintext/Cargo.toml
@@ -22,8 +22,8 @@ void = "1.0.2"
 
 [dev-dependencies]
 env_logger = "0.9.0"
-quickcheck = "0.9.0"
-rand = "0.7"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
+rand = "0.8"
 
 [build-dependencies]
 prost-build = "0.11"
diff --git a/transports/pnet/CHANGELOG.md b/transports/pnet/CHANGELOG.md
index 4b764219f4f..68dc9180df7 100644
--- a/transports/pnet/CHANGELOG.md
+++ b/transports/pnet/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.22.1 [unreleased]
+
+- Bump rand to 0.8 and quickcheck to 1. See [PR 2857].
+
+[PR 2857]: https://github.com/libp2p/rust-libp2p/pull/2857
+
 # 0.22.0 [2021-11-01]
 
 - Update dependencies.
diff --git a/transports/pnet/Cargo.toml b/transports/pnet/Cargo.toml
index b674f18ab97..ca977c31a1a 100644
--- a/transports/pnet/Cargo.toml
+++ b/transports/pnet/Cargo.toml
@@ -3,7 +3,7 @@ name = "libp2p-pnet"
 edition = "2021"
 rust-version = "1.56.1"
 description = "Private swarm support for libp2p"
-version = "0.22.0"
+version = "0.22.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -15,8 +15,8 @@ futures = "0.3.1"
 log = "0.4.8"
 salsa20 = "0.9"
 sha3 = "0.10"
-rand = "0.7"
+rand = "0.8"
 pin-project = "1.0.2"
 
 [dev-dependencies]
-quickcheck = "0.9.0"
+quickcheck = { package = "quickcheck-ext", path = "../../misc/quickcheck-ext" }
diff --git a/transports/pnet/src/lib.rs b/transports/pnet/src/lib.rs
index efd27b14667..c4d6e7cc720 100644
--- a/transports/pnet/src/lib.rs
+++ b/transports/pnet/src/lib.rs
@@ -319,9 +319,8 @@ mod tests {
     use quickcheck::*;
 
     impl Arbitrary for PreSharedKey {
-        fn arbitrary<G: Gen>(g: &mut G) -> PreSharedKey {
-            let mut key = [0; KEY_SIZE];
-            g.fill_bytes(&mut key);
+        fn arbitrary(g: &mut Gen) -> PreSharedKey {
+            let key = core::array::from_fn(|_| u8::arbitrary(g));
             PreSharedKey(key)
         }
     }