diff --git a/components/style/stylist.rs b/components/style/stylist.rs
index 8f9d2a9736e..7298e0d2fc9 100644
--- a/components/style/stylist.rs
+++ b/components/style/stylist.rs
@@ -1979,7 +1979,7 @@ impl CascadeData {
             selectors_for_cache_revalidation: SelectorMap::new_without_attribute_bucketing(),
             animations: Default::default(),
             layer_order: Default::default(),
-            next_layer_order: 0,
+            next_layer_order: 1, // 0 reserved for the root scope.
             extra_data: ExtraStyleData::default(),
             effective_media_query_results: EffectiveMediaQueryResults::new(),
             rules_source_order: 0,
@@ -2143,6 +2143,7 @@ impl CascadeData {
         guard: &SharedRwLockReadGuard,
         rebuild_kind: SheetRebuildKind,
         current_layer: &mut LayerName,
+        current_layer_order: u32,
         mut precomputed_pseudo_element_decls: Option<&mut PrecomputedPseudoElementDeclarations>,
     ) -> Result<(), FailedAllocationError>
     where
@@ -2190,6 +2191,7 @@ impl CascadeData {
                             hashes,
                             locked.clone(),
                             self.rules_source_order,
+                            current_layer_order,
                         );
 
                         if rebuild_kind.should_rebuild_invalidation() {
@@ -2327,6 +2329,7 @@ impl CascadeData {
             }
 
             let mut layer_names_to_pop = 0;
+            let mut children_layer_order = current_layer_order;
             match *rule {
                 CssRule::Import(ref lock) => {
                     if rebuild_kind.should_rebuild_invalidation() {
@@ -2345,15 +2348,17 @@ impl CascadeData {
                 CssRule::Layer(ref lock) => {
                     use crate::stylesheets::layer_rule::LayerRuleKind;
 
-                    fn maybe_register_layer(data: &mut CascadeData, layer: &LayerName) {
+                    fn maybe_register_layer(data: &mut CascadeData, layer: &LayerName) -> u32 {
                         // TODO: Measure what's more common / expensive, if
                         // layer.clone() or the double hash lookup in the insert
                         // case.
-                        if data.layer_order.get(layer).is_some() {
-                            return;
+                        if let Some(order) = data.layer_order.get(layer) {
+                            return *order;
                         }
-                        data.layer_order.insert(layer.clone(), data.next_layer_order);
+                        let order = data.next_layer_order;
+                        data.layer_order.insert(layer.clone(), order);
                         data.next_layer_order += 1;
+                        order
                     }
 
                     let layer_rule = lock.read_with(guard);
@@ -2361,7 +2366,7 @@ impl CascadeData {
                         LayerRuleKind::Block { ref name, .. } => {
                             for name in name.layer_names() {
                                 current_layer.0.push(name.clone());
-                                maybe_register_layer(self, &current_layer);
+                                children_layer_order = maybe_register_layer(self, &current_layer);
                                 layer_names_to_pop += 1;
                             }
                         }
@@ -2389,6 +2394,7 @@ impl CascadeData {
                     guard,
                     rebuild_kind,
                     current_layer,
+                    children_layer_order,
                     precomputed_pseudo_element_decls.as_deref_mut(),
                 )?;
             }
@@ -2433,6 +2439,7 @@ impl CascadeData {
             guard,
             rebuild_kind,
             &mut current_layer,
+            /* current_layer_order = */ 0,
             precomputed_pseudo_element_decls.as_deref_mut(),
         )?;
 
@@ -2551,7 +2558,7 @@ impl CascadeData {
         }
         self.animations.clear();
         self.layer_order.clear();
-        self.next_layer_order = 0;
+        self.next_layer_order = 1;
         self.extra_data.clear();
         self.rules_source_order = 0;
         self.num_selectors = 0;
@@ -2640,6 +2647,9 @@ pub struct Rule {
     /// we could repurpose that storage here if we needed to.
     pub source_order: u32,
 
+    /// The current layer order of this style rule.
+    pub layer_order: u32,
+
     /// The actual style rule.
     #[cfg_attr(
         feature = "gecko",
@@ -2677,12 +2687,14 @@ impl Rule {
         hashes: AncestorHashes,
         style_rule: Arc<Locked<StyleRule>>,
         source_order: u32,
+        layer_order: u32,
     ) -> Self {
         Rule {
-            selector: selector,
-            hashes: hashes,
-            style_rule: style_rule,
-            source_order: source_order,
+            selector,
+            hashes,
+            style_rule,
+            source_order,
+            layer_order,
         }
     }
 }