diff --git a/Cargo.lock b/Cargo.lock
index 5f1c123357ee6..aaa086ee28264 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4316,6 +4316,7 @@ name = "node-runtime"
 version = "2.0.1"
 dependencies = [
  "frame-benchmarking",
+ "frame-election-provider-support",
  "frame-executive",
  "frame-support",
  "frame-system",
@@ -5373,6 +5374,7 @@ dependencies = [
  "frame-system",
  "impl-trait-for-tuples",
  "lazy_static",
+ "log",
  "pallet-timestamp",
  "parity-scale-codec",
  "sp-application-crypto",
diff --git a/bin/node/runtime/Cargo.toml b/bin/node/runtime/Cargo.toml
index 335d9a1aa2a98..f1eb30213e8e2 100644
--- a/bin/node/runtime/Cargo.toml
+++ b/bin/node/runtime/Cargo.toml
@@ -43,6 +43,7 @@ frame-benchmarking = { version = "3.1.0", default-features = false, path = "../.
 frame-support = { version = "3.0.0", default-features = false, path = "../../../frame/support" }
 frame-system = { version = "3.0.0", default-features = false, path = "../../../frame/system" }
 frame-system-benchmarking = { version = "3.0.0", default-features = false, path = "../../../frame/system/benchmarking", optional = true }
+frame-election-provider-support = { version = "3.0.0", default-features = false, path = "../../../frame/election-provider-support" }
 frame-system-rpc-runtime-api = { version = "3.0.0", default-features = false, path = "../../../frame/system/rpc/runtime-api/" }
 frame-try-runtime = { version = "0.9.0", default-features = false, path = "../../../frame/try-runtime", optional = true }
 pallet-assets = { version = "3.0.0", default-features = false, path = "../../../frame/assets" }
diff --git a/bin/node/runtime/src/lib.rs b/bin/node/runtime/src/lib.rs
index 11a50aef18b69..d09ee510065dd 100644
--- a/bin/node/runtime/src/lib.rs
+++ b/bin/node/runtime/src/lib.rs
@@ -467,7 +467,7 @@ pallet_staking_reward_curve::build! {
 }
 
 parameter_types! {
-	pub const SessionsPerEra: sp_staking::SessionIndex = 3; // TODO: just for testing, revert at last.
+	pub const SessionsPerEra: sp_staking::SessionIndex = 1; // TODO: just for testing, revert at last.
 	pub const BondingDuration: pallet_staking::EraIndex = 24 * 28;
 	pub const SlashDeferDuration: pallet_staking::EraIndex = 24 * 7; // 1/4 the bonding duration.
 	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
@@ -475,6 +475,7 @@ parameter_types! {
 	pub OffchainRepeat: BlockNumber = 5;
 }
 
+use frame_election_provider_support::onchain;
 impl pallet_staking::Config for Runtime {
 	const MAX_NOMINATIONS: u32 = MAX_NOMINATIONS;
 	type Currency = Balances;
@@ -498,6 +499,8 @@ impl pallet_staking::Config for Runtime {
 	type NextNewSession = Session;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type ElectionProvider = ElectionProviderMultiPhase;
+	type GenesisElectionProvider =
+		onchain::OnChainSequentialPhragmen<pallet_election_provider_multi_phase::OnChainConfig<Self>>;
 	type WeightInfo = pallet_staking::weights::SubstrateWeight<Runtime>;
 }
 
diff --git a/frame/babe/src/mock.rs b/frame/babe/src/mock.rs
index 40ee782e721d6..7e7b36a456744 100644
--- a/frame/babe/src/mock.rs
+++ b/frame/babe/src/mock.rs
@@ -211,6 +211,7 @@ impl pallet_staking::Config for Test {
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type NextNewSession = Session;
 	type ElectionProvider = onchain::OnChainSequentialPhragmen<Self>;
+	type GenesisElectionProvider = Self::ElectionProvider;
 	type WeightInfo = ();
 }
 
diff --git a/frame/election-provider-multi-phase/src/lib.rs b/frame/election-provider-multi-phase/src/lib.rs
index 9cd46dc96c641..b32c9fdbf4df6 100644
--- a/frame/election-provider-multi-phase/src/lib.rs
+++ b/frame/election-provider-multi-phase/src/lib.rs
@@ -285,7 +285,7 @@ pub type CompactAccuracyOf<T> = <CompactOf<T> as CompactSolution>::Accuracy;
 pub type OnChainAccuracyOf<T> = <T as Config>::OnChainAccuracy;
 
 /// Wrapper type that implements the configurations needed for the on-chain backup.
-struct OnChainConfig<T: Config>(sp_std::marker::PhantomData<T>);
+pub struct OnChainConfig<T: Config>(sp_std::marker::PhantomData<T>);
 impl<T: Config> onchain::Config for OnChainConfig<T> {
 	type AccountId = T::AccountId;
 	type BlockNumber = T::BlockNumber;
@@ -1277,27 +1277,17 @@ impl<T: Config> ElectionProvider<T::AccountId, T::BlockNumber> for Pallet<T> {
 	type DataProvider = T::DataProvider;
 
 	fn elect() -> Result<(Supports<T::AccountId>, Weight), Self::Error> {
-		if Self::round() > 1 {
-			match Self::do_elect() {
-				Ok((supports, weight)) => {
-					// all went okay, put sign to be Off, clean snapshot, etc.
-					Self::rotate_round();
-					Ok((supports, weight))
-				}
-				Err(why) => {
-					log!(error, "Entering emergency mode.");
-					<CurrentPhase<T>>::put(Phase::Emergency);
-					Err(why)
-				}
+		match Self::do_elect() {
+			Ok((supports, weight)) => {
+				// all went okay, put sign to be Off, clean snapshot, etc.
+				Self::rotate_round();
+				Ok((supports, weight))
+			}
+			Err(why) => {
+				log!(error, "Entering emergency mode.");
+				<CurrentPhase<T>>::put(Phase::Emergency);
+				Err(why)
 			}
-		} else {
-			// first round, always run on-chain.
-			// TODO: move all of this into a new trait like `GenesisElectionProvide`, or a new
-			// function in the same trait.
-			let result = Self::onchain_fallback();
-			log!(info, "Finalized initial election round with onchain compute.");
-			Self::rotate_round();
-			result
 		}
 	}
 }
diff --git a/frame/grandpa/src/mock.rs b/frame/grandpa/src/mock.rs
index 1ab28f7752ef0..0bbd0cc966749 100644
--- a/frame/grandpa/src/mock.rs
+++ b/frame/grandpa/src/mock.rs
@@ -217,6 +217,7 @@ impl pallet_staking::Config for Test {
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type NextNewSession = Session;
 	type ElectionProvider = onchain::OnChainSequentialPhragmen<Self>;
+	type GenesisElectionProvider = Self::ElectionProvider;
 	type WeightInfo = ();
 }
 
diff --git a/frame/offences/benchmarking/src/mock.rs b/frame/offences/benchmarking/src/mock.rs
index 9047120923ad6..c62521b945c8d 100644
--- a/frame/offences/benchmarking/src/mock.rs
+++ b/frame/offences/benchmarking/src/mock.rs
@@ -176,6 +176,7 @@ impl pallet_staking::Config for Test {
 	type NextNewSession = Session;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type ElectionProvider = onchain::OnChainSequentialPhragmen<Self>;
+	type GenesisElectionProvider = Self::ElectionProvider;
 	type WeightInfo = ();
 }
 
diff --git a/frame/session/Cargo.toml b/frame/session/Cargo.toml
index 44e1f2f67858b..efe7bc133fb4d 100644
--- a/frame/session/Cargo.toml
+++ b/frame/session/Cargo.toml
@@ -24,6 +24,7 @@ frame-support = { version = "3.0.0", default-features = false, path = "../suppor
 frame-system = { version = "3.0.0", default-features = false, path = "../system" }
 pallet-timestamp = { version = "3.0.0", default-features = false, path = "../timestamp" }
 sp-trie = { version = "3.0.0", optional = true, default-features = false, path = "../../primitives/trie" }
+log = { version = "0.4.0", default-features = false }
 impl-trait-for-tuples = "0.2.1"
 
 [dev-dependencies]
@@ -44,5 +45,6 @@ std = [
 	"sp-staking/std",
 	"pallet-timestamp/std",
 	"sp-trie/std",
+	"log/std",
 ]
 try-runtime = ["frame-support/try-runtime"]
diff --git a/frame/session/benchmarking/src/mock.rs b/frame/session/benchmarking/src/mock.rs
index cf2fa8a07cfe0..f2d3a493ea9ae 100644
--- a/frame/session/benchmarking/src/mock.rs
+++ b/frame/session/benchmarking/src/mock.rs
@@ -181,6 +181,7 @@ impl pallet_staking::Config for Test {
 	type NextNewSession = Session;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type ElectionProvider = onchain::OnChainSequentialPhragmen<Self>;
+	type GenesisElectionProvider = Self::ElectionProvider;
 	type WeightInfo = ();
 }
 
diff --git a/frame/session/src/historical/mod.rs b/frame/session/src/historical/mod.rs
index 8902ebe551f6c..a0c38ae6a182d 100644
--- a/frame/session/src/historical/mod.rs
+++ b/frame/session/src/historical/mod.rs
@@ -124,10 +124,17 @@ impl<T: Config> ValidatorSetWithIdentification<T::AccountId> for Module<T> {
 
 /// Specialization of the crate-level `SessionManager` which returns the set of full identification
 /// when creating a new session.
-pub trait SessionManager<ValidatorId, FullIdentification>: crate::SessionManager<ValidatorId> {
+pub trait SessionManager<ValidatorId, FullIdentification>:
+	crate::SessionManager<ValidatorId>
+{
 	/// If there was a validator set change, its returns the set of new validators along with their
 	/// full identifications.
 	fn new_session(new_index: SessionIndex) -> Option<Vec<(ValidatorId, FullIdentification)>>;
+	fn new_session_genesis(
+		new_index: SessionIndex,
+	) -> Option<Vec<(ValidatorId, FullIdentification)>> {
+		<Self as SessionManager<_, _>>::new_session(new_index)
+	}
 	fn start_session(start_index: SessionIndex);
 	fn end_session(end_index: SessionIndex);
 }
@@ -136,19 +143,20 @@ pub trait SessionManager<ValidatorId, FullIdentification>: crate::SessionManager
 /// sets the historical trie root of the ending session.
 pub struct NoteHistoricalRoot<T, I>(sp_std::marker::PhantomData<(T, I)>);
 
-impl<T: Config, I> crate::SessionManager<T::ValidatorId> for NoteHistoricalRoot<T, I>
-	where I: SessionManager<T::ValidatorId, T::FullIdentification>
-{
-	fn new_session(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {
-
+impl<T: Config, I: SessionManager<T::ValidatorId, T::FullIdentification>> NoteHistoricalRoot<T, I> {
+	fn do_new_session(new_index: SessionIndex, is_genesis: bool) -> Option<Vec<T::ValidatorId>> {
 		StoredRange::mutate(|range| {
 			range.get_or_insert_with(|| (new_index, new_index)).1 = new_index + 1;
 		});
 
-		let new_validators_and_id = <I as SessionManager<_, _>>::new_session(new_index);
-		let new_validators = new_validators_and_id.as_ref().map(|new_validators| {
-			new_validators.iter().map(|(v, _id)| v.clone()).collect()
-		});
+		let new_validators_and_id = if is_genesis {
+			<I as SessionManager<_, _>>::new_session_genesis(new_index)
+		} else {
+			<I as SessionManager<_, _>>::new_session(new_index)
+		};
+		let new_validators = new_validators_and_id
+			.as_ref()
+			.map(|new_validators| new_validators.iter().map(|(v, _id)| v.clone()).collect());
 
 		if let Some(new_validators) = new_validators_and_id {
 			let count = new_validators.len() as ValidatorCount;
@@ -168,6 +176,19 @@ impl<T: Config, I> crate::SessionManager<T::ValidatorId> for NoteHistoricalRoot<
 
 		new_validators
 	}
+}
+
+impl<T: Config, I> crate::SessionManager<T::ValidatorId> for NoteHistoricalRoot<T, I>
+where
+	I: SessionManager<T::ValidatorId, T::FullIdentification>,
+{
+	fn new_session(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {
+		Self::do_new_session(new_index, false)
+	}
+
+	fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {
+		Self::do_new_session(new_index, true)
+	}
 
 	fn start_session(start_index: SessionIndex) {
 		<I as SessionManager<_, _>>::start_session(start_index)
diff --git a/frame/session/src/lib.rs b/frame/session/src/lib.rs
index 8574979ef2fea..c9bfb0bcf7c61 100644
--- a/frame/session/src/lib.rs
+++ b/frame/session/src/lib.rs
@@ -238,12 +238,19 @@ pub trait SessionManager<ValidatorId> {
 	/// `new_session(session)` is guaranteed to be called before `end_session(session-1)`. In other
 	/// words, a new session must always be planned before an ongoing one can be finished.
 	fn new_session(new_index: SessionIndex) -> Option<Vec<ValidatorId>>;
+	/// Same as `new_session`, but it this should only be called at genesis.
+	///
+	/// The session manager might decide to treat this in a different way. Default impl is simply
+	/// using [`new_session`].
+	fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<ValidatorId>> {
+		Self::new_session(new_index)
+	}
 	/// End the session.
 	///
 	/// Because the session pallet can queue validator set the ending session can be lower than the
 	/// last new session index.
 	fn end_session(end_index: SessionIndex);
-	/// Start the session.
+	/// Start an already planned the session.
 	///
 	/// The session start to be used for validation.
 	fn start_session(start_index: SessionIndex);
@@ -340,13 +347,9 @@ impl<AId> SessionHandler<AId> for Tuple {
 pub struct TestSessionHandler;
 impl<AId> SessionHandler<AId> for TestSessionHandler {
 	const KEY_TYPE_IDS: &'static [KeyTypeId] = &[sp_runtime::key_types::DUMMY];
-
 	fn on_genesis_session<Ks: OpaqueKeys>(_: &[(AId, Ks)]) {}
-
 	fn on_new_session<Ks: OpaqueKeys>(_: bool, _: &[(AId, Ks)], _: &[(AId, Ks)]) {}
-
 	fn on_before_session_ending() {}
-
 	fn on_disabled(_: usize) {}
 }
 
@@ -451,7 +454,7 @@ decl_storage! {
 				}
 			}
 
-			let initial_validators_0 = T::SessionManager::new_session(0)
+			let initial_validators_0 = T::SessionManager::new_session_genesis(0)
 				.unwrap_or_else(|| {
 					frame_support::print("No initial validator provided by `SessionManager`, use \
 						session config keys to generate initial validator set.");
@@ -459,7 +462,7 @@ decl_storage! {
 				});
 			assert!(!initial_validators_0.is_empty(), "Empty validator set for session 0 in genesis block!");
 
-			let initial_validators_1 = T::SessionManager::new_session(1)
+			let initial_validators_1 = T::SessionManager::new_session_genesis(1)
 				.unwrap_or_else(|| initial_validators_0.clone());
 			assert!(!initial_validators_1.is_empty(), "Empty validator set for session 1 in genesis block!");
 
@@ -548,7 +551,7 @@ decl_module! {
 		///   Actual cost depends on the number of length of `T::Keys::key_ids()` which is fixed.
 		/// - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`
 		/// - DbWrites: `NextKeys`, `origin account`
-		/// - DbWrites per key id: `KeyOwnder`
+		/// - DbWrites per key id: `KeyOwner`
 		/// # </weight>
 		#[weight = T::WeightInfo::purge_keys()]
 		pub fn purge_keys(origin) {
@@ -573,17 +576,17 @@ decl_module! {
 }
 
 impl<T: Config> Module<T> {
-	/// Move on to next session. Register new validator set and session keys. Changes
-	/// to the validator set have a session of delay to take effect. This allows for
-	/// equivocation punishment after a fork.
+	/// Move on to next session. Register new validator set and session keys. Changes to the
+	/// validator set have a session of delay to take effect. This allows for equivocation
+	/// punishment after a fork.
 	pub fn rotate_session() {
 		let session_index = CurrentIndex::get();
+		log::trace!(target: "runtime::session", "rotating session {:?}", session_index);
 
 		let changed = QueuedChanged::get();
 
 		// Inform the session handlers that a session is going to end.
 		T::SessionHandler::on_before_session_ending();
-
 		T::SessionManager::end_session(session_index);
 
 		// Get queued session keys and validators.
diff --git a/frame/staking/src/benchmarking.rs b/frame/staking/src/benchmarking.rs
index 89c90d05e331e..973f34ce5236d 100644
--- a/frame/staking/src/benchmarking.rs
+++ b/frame/staking/src/benchmarking.rs
@@ -91,7 +91,7 @@ pub fn create_validator_with_nominators<T: Config>(
 	ValidatorCount::put(1);
 
 	// Start a new Era
-	let new_validators = Staking::<T>::try_trigger_new_era(SessionIndex::one()).unwrap();
+	let new_validators = Staking::<T>::try_trigger_new_era(SessionIndex::one(), true).unwrap();
 
 	assert_eq!(new_validators.len(), 1);
 	assert_eq!(new_validators[0], v_stash, "Our validator was not selected!");
@@ -484,7 +484,7 @@ benchmarks! {
 		)?;
 		let session_index = SessionIndex::one();
 	}: {
-		let validators = Staking::<T>::try_trigger_new_era(session_index)
+		let validators = Staking::<T>::try_trigger_new_era(session_index, true)
 			.ok_or("`new_era` failed")?;
 		assert!(validators.len() == v as usize);
 	}
@@ -501,7 +501,7 @@ benchmarks! {
 			None,
 		)?;
 		// Start a new Era
-		let new_validators = Staking::<T>::try_trigger_new_era(SessionIndex::one()).unwrap();
+		let new_validators = Staking::<T>::try_trigger_new_era(SessionIndex::one(), true).unwrap();
 		assert!(new_validators.len() == v as usize);
 
 		let current_era = CurrentEra::get().unwrap();
diff --git a/frame/staking/src/lib.rs b/frame/staking/src/lib.rs
index 00d6d3ddac1a3..612bc77ab89a8 100644
--- a/frame/staking/src/lib.rs
+++ b/frame/staking/src/lib.rs
@@ -738,6 +738,13 @@ pub trait Config: frame_system::Config + SendTransactionTypes<Call<Self>> {
 		DataProvider = Module<Self>,
 	>;
 
+	/// Something that provides the election functionality at genesis.
+	type GenesisElectionProvider: frame_election_provider_support::ElectionProvider<
+		Self::AccountId,
+		Self::BlockNumber,
+		DataProvider = Module<Self>,
+	>;
+
 	/// Maximum number of nominations per nominator.
 	const MAX_NOMINATIONS: u32;
 
@@ -2139,7 +2146,7 @@ impl<T: Config> Module<T> {
 	}
 
 	/// Plan a new session potentially trigger a new era.
-	fn new_session(session_index: SessionIndex) -> Option<Vec<T::AccountId>> {
+	fn new_session(session_index: SessionIndex, is_genesis: bool) -> Option<Vec<T::AccountId>> {
 		if let Some(current_era) = Self::current_era() {
 			// Initial era has been set.
 			let current_era_start_session_index = Self::eras_start_session_index(current_era)
@@ -2166,7 +2173,7 @@ impl<T: Config> Module<T> {
 			}
 
 			// New era.
-			let maybe_new_era_validators = Self::try_trigger_new_era(session_index);
+			let maybe_new_era_validators = Self::try_trigger_new_era(session_index, is_genesis);
 			if maybe_new_era_validators.is_some() && matches!(ForceEra::get(), Forcing::ForceNew) {
 				ForceEra::kill();
 			}
@@ -2175,7 +2182,7 @@ impl<T: Config> Module<T> {
 		} else {
 			// Set initial era.
 			log!(debug, "Starting the first era.");
-			Self::try_trigger_new_era(session_index)
+			Self::try_trigger_new_era(session_index, is_genesis)
 		}
 	}
 
@@ -2306,13 +2313,19 @@ impl<T: Config> Module<T> {
 	/// In case election result has more than [`MinimumValidatorCount`] validator trigger a new era.
 	///
 	/// In case a new era is planned, the new validator set is returned.
-	fn try_trigger_new_era(start_session_index: SessionIndex) -> Option<Vec<T::AccountId>> {
-		let (election_result, weight) = T::ElectionProvider::elect()
-			.map_err(|e| {
+	fn try_trigger_new_era(start_session_index: SessionIndex, is_genesis: bool) -> Option<Vec<T::AccountId>> {
+		let (election_result, weight) = if is_genesis {
+			T::GenesisElectionProvider::elect().map_err(|e| {
+				log!(warn, "genesis election provider failed due to {:?}", e);
+				Self::deposit_event(RawEvent::StakingElectionFailed);
+			})
+		} else {
+			T::ElectionProvider::elect().map_err(|e| {
 				log!(warn, "election provider failed due to {:?}", e);
 				Self::deposit_event(RawEvent::StakingElectionFailed);
 			})
-			.ok()?;
+		}
+		.ok()?;
 
 		<frame_system::Pallet<T>>::register_extra_weight_unchecked(
 			weight,
@@ -2707,16 +2720,21 @@ impl<T: Config> frame_election_provider_support::ElectionDataProvider<T::Account
 /// some session can lag in between the newest session planned and the latest session started.
 impl<T: Config> pallet_session::SessionManager<T::AccountId> for Module<T> {
 	fn new_session(new_index: SessionIndex) -> Option<Vec<T::AccountId>> {
-		log!(trace, "planning new_session({})", new_index);
+		log!(trace, "planning new session {}", new_index);
 		CurrentPlannedSession::put(new_index);
-		Self::new_session(new_index)
+		Self::new_session(new_index, false)
+	}
+	fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<T::AccountId>> {
+		log!(trace, "planning new session {} at genesis", new_index);
+		CurrentPlannedSession::put(new_index);
+		Self::new_session(new_index, true)
 	}
 	fn start_session(start_index: SessionIndex) {
-		log!(trace, "starting start_session({})", start_index);
+		log!(trace, "starting session {}", start_index);
 		Self::start_session(start_index)
 	}
 	fn end_session(end_index: SessionIndex) {
-		log!(trace, "ending end_session({})", end_index);
+		log!(trace, "ending session {}", end_index);
 		Self::end_session(end_index)
 	}
 }
@@ -2738,6 +2756,20 @@ impl<T: Config> historical::SessionManager<T::AccountId, Exposure<T::AccountId,
 			}).collect()
 		})
 	}
+	fn new_session_genesis(
+		new_index: SessionIndex,
+	) -> Option<Vec<(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>)>> {
+		<Self as pallet_session::SessionManager<_>>::new_session_genesis(new_index).map(|validators| {
+			let current_era = Self::current_era()
+				// Must be some as a new era has been created.
+				.unwrap_or(0);
+
+			validators.into_iter().map(|v| {
+				let exposure = Self::eras_stakers(current_era, &v);
+				(v, exposure)
+			}).collect()
+		})
+	}
 	fn start_session(start_index: SessionIndex) {
 		<Self as pallet_session::SessionManager<_>>::start_session(start_index)
 	}
diff --git a/frame/staking/src/mock.rs b/frame/staking/src/mock.rs
index 4027ac1f670bc..464b91e0cc507 100644
--- a/frame/staking/src/mock.rs
+++ b/frame/staking/src/mock.rs
@@ -259,6 +259,7 @@ impl Config for Test {
 	type NextNewSession = Session;
 	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
 	type ElectionProvider = onchain::OnChainSequentialPhragmen<Self>;
+	type GenesisElectionProvider = Self::ElectionProvider;
 	type WeightInfo = ();
 }