diff --git a/lib/core/utils/preload-cssom.js b/lib/core/utils/preload-cssom.js
index 6cea9cf1bb..fb62f23817 100644
--- a/lib/core/utils/preload-cssom.js
+++ b/lib/core/utils/preload-cssom.js
@@ -1,58 +1,82 @@
 /**
- * Returns a then(able) queue of CSSStyleSheet(s)
- * @param {Object} ownerDocument document object to be inspected for stylesheets
- * @param {number} timeout on network request for stylesheet that need to be externally fetched
- * @param {Function} convertTextToStylesheetFn a utility function to generate a style sheet from text
- * @return {Object} queue
+ * Make an axios get request to fetch a given resource and resolve
+ * @method getExternalStylesheet
+ * @param {Object} options an object with properties to configure the external XHR
+ * @property {Object} options.resolve resolve callback on queue
+ * @property {Object} options.reject reject callback on queue
+ * @property {String} options.url string representing the url of the resource to load
+ * @property {Object} options.rootNode document or shadowDOM root document for which to process CSSOM
+ * @property {Number} options.timeout timeout to about network call
+ * @property {Function} options.getStyleSheet a utility function to generate a style sheet for a given text content
+ * @property {String} options.shadowId an id if undefined denotes that given root is a shadowRoot
+ * @property {Number} options.priority css applied priority
+ * @returns resolve with stylesheet object
  * @private
  */
-function loadCssom({ root, shadowId }, timeout, convertTextToStylesheetFn) {
-	/**
-	 * Make an axios get request to fetch a given resource and resolve
-	 * @method getExternalStylesheet
-	 * @private
-	 * @param {Object} param an object with properties to configure the external XHR
-	 * @property {Object} param.resolve resolve callback on queue
-	 * @property {Object} param.reject reject callback on queue
-	 * @property {String} param.url string representing the url of the resource to load
-	 * @property {Number} param.timeout timeout to about network call
-	 */
-	function getExternalStylesheet({ resolve, reject, url }) {
-		axe.imports
-			.axios({
-				method: 'get',
-				url,
-				timeout
-			})
-			.then(({ data }) => {
-				const sheet = convertTextToStylesheetFn({
-					data,
-					isExternal: true,
-					shadowId,
-					root
-				});
-				resolve(sheet);
-			})
-			.catch(reject);
-	}
-
-	const q = axe.utils.queue();
+function getExternalStylesheet(options) {
+	const {
+		resolve,
+		reject,
+		url,
+		rootNode,
+		timeout,
+		getStyleSheet,
+		shadowId,
+		priority
+	} = options;
+	axe.imports
+		.axios({
+			method: 'get',
+			url,
+			timeout
+		})
+		.then(({ data }) => {
+			const sheet = getStyleSheet({
+				data,
+				isExternal: true,
+				shadowId,
+				root: rootNode,
+				priority
+			});
+			resolve(sheet);
+		})
+		.catch(reject);
+}
 
-	// handle .styleSheets non existent on certain shadowDOM root
-	const rootStyleSheets = root.styleSheets
-		? Array.from(root.styleSheets)
-		: null;
-	if (!rootStyleSheets) {
-		return q;
-	}
+/**
+ * Get stylesheet(s) from shadowDOM
+ * @param {Object} documentFragment document fragment node
+ * @param {Function} getStyleSheet helper function to get stylesheet object
+ * @returns an array of stylesheet objects
+ */
+function getSheetsFromShadowDom(documentFragment, getStyleSheet) {
+	return Array.from(documentFragment.children).reduce((out, node) => {
+		const nodeName = node.nodeName.toUpperCase();
+		if (nodeName !== 'STYLE' && nodeName !== 'LINK') {
+			return out;
+		}
+		if (nodeName === 'STYLE') {
+			const dynamicSheet = getStyleSheet({ data: node.textContent });
+			out.push(dynamicSheet.sheet);
+		}
+		if (nodeName === 'LINK' && !node.media.includes('print')) {
+			const dynamicSheet = getStyleSheet({ data: node, isLink: true });
+			out.push(dynamicSheet.sheet);
+		}
+		return out;
+	}, []);
+}
 
-	// convenience array fot help unique sheets if duplicated by same `href`
-	// both external and internal sheets
+/**
+ * Filter a given array of stylesheet objects
+ * @param {Array<Object>} styleSheets array of stylesheets
+ * @returns an filtered array of stylesheets
+ */
+function filterStyleSheets(styleSheets) {
 	let sheetHrefs = [];
 
-	// filter out sheets, that should not be accounted for...
-	const sheets = rootStyleSheets.filter(sheet => {
-		// FILTER > sheets with the same href (if exists)
+	return styleSheets.filter(sheet => {
+		// 1) FILTER > sheets with the same href
 		let sheetAlreadyExists = false;
 		if (sheet.href) {
 			if (!sheetHrefs.includes(sheet.href)) {
@@ -61,81 +85,112 @@ function loadCssom({ root, shadowId }, timeout, convertTextToStylesheetFn) {
 				sheetAlreadyExists = true;
 			}
 		}
-		// FILTER > media='print'
-		// Note:
-		// Chrome does this automagically, Firefox returns every sheet
-		// hence the need to filter
+		// 2) FILTER > media='print'
 		const isPrintMedia = Array.from(sheet.media).includes('print');
-		// FILTER > disabled
-		// Firefox does not respect `disabled` attribute on stylesheet
-		// Hence decided not to filter out disabled for the time being
 
-		// return
 		return !isPrintMedia && !sheetAlreadyExists;
 	});
+}
+
+/**
+ * Returns a then(able) queue of CSSStyleSheet(s)
+ * @method loadCssom
+ * @private
+ * @param {Object} options an object with attributes essential to load CSSOM
+ * @property {Object} options.rootNode document or shadowDOM root document for which to process CSSOM
+ * @property {Number} options.rootIndex a number representing the index of the document or shadowDOM, used for priority
+ * @property {String} options.shadowId an id if undefined denotes that given root is a shadowRoot
+ * @property {Number} options.timeout abort duration for network request
+ * @param {Function} options.getStyleSheet a utility function to generate a style sheet for a given text content
+ * @return {Object} queue
+ */
+function loadCssom(options) {
+	const { rootNode, rootIndex, shadowId, getStyleSheet } = options;
+	const q = axe.utils.queue();
+	const styleSheets =
+		rootNode.nodeType === 11 && shadowId
+			? getSheetsFromShadowDom(rootNode, getStyleSheet)
+			: Array.from(rootNode.styleSheets);
+	const sheets = filterStyleSheets(styleSheets);
+
+	sheets.forEach((sheet, sheetIndex) => {
+		/* eslint max-statements: ["error", 20] */
+		const priority = [rootIndex, sheetIndex];
 
-	// iterate to decipher multi-level nested sheets if any (this is essential to retrieve styles from shadowDOM)
-	sheets.forEach(sheet => {
-		// attempt to retrieve cssRules, or for external sheets make a XMLHttpRequest
 		try {
-			// accessing .cssRules throws for external (cross-domain) sheets, which is handled in the catch
+			// The following line throws an error on cross-origin style sheets:
 			const cssRules = sheet.cssRules;
-			// read all css rules in the sheet
 			const rules = Array.from(cssRules);
+			if (!rules.length) {
+				return;
+			}
 
 			// filter rules that are included by way of @import or nested link
 			const importRules = rules.filter(r => r.href);
-
-			// if no import or nested link rules, with in these cssRules
-			// return current sheet
 			if (!importRules.length) {
 				q.defer(resolve =>
 					resolve({
 						sheet,
 						isExternal: false,
 						shadowId,
-						root
+						root: rootNode,
+						priority
 					})
 				);
 				return;
 			}
 
-			// if any import rules exists, fetch via `href` which eventually constructs a sheet with results from resource
+			// for import rules, fetch via `href`
 			importRules.forEach(rule => {
 				q.defer((resolve, reject) => {
-					getExternalStylesheet({ resolve, reject, url: rule.href });
+					getExternalStylesheet({
+						resolve,
+						reject,
+						url: rule.href,
+						priority,
+						...options
+					});
 				});
 			});
 
 			// in the same sheet -  get inline rules in <style> tag or in a CSSStyleSheet excluding @import or nested link
 			const inlineRules = rules.filter(rule => !rule.href);
+			if (!inlineRules.length) {
+				return;
+			}
 
-			// concat all cssText into a string for inline rules
+			// concat all cssText into a string for inline rules & create sheet
 			const inlineRulesCssText = inlineRules
 				.reduce((out, rule) => {
 					out.push(rule.cssText);
 					return out;
 				}, [])
 				.join();
-			// create and return a sheet with inline rules
 			q.defer(resolve =>
 				resolve(
-					convertTextToStylesheetFn({
+					getStyleSheet({
 						data: inlineRulesCssText,
 						shadowId,
-						root,
-						isExternal: false
+						root: rootNode,
+						isExternal: false,
+						priority
 					})
 				)
 			);
 		} catch (e) {
 			// external sheet -> make an xhr and q the response
 			q.defer((resolve, reject) => {
-				getExternalStylesheet({ resolve, reject, url: sheet.href });
+				getExternalStylesheet({
+					resolve,
+					reject,
+					url: sheet.href,
+					priority,
+					...options
+				});
 			});
 		}
-	}, []);
-	// return
+	});
+
 	return q;
 }
 
@@ -158,7 +213,7 @@ function getAllRootsInTree(tree) {
 		.map(node => {
 			return {
 				shadowId: node.shadowId,
-				root: axe.utils.getRootNode(node.actualNode)
+				rootNode: axe.utils.getRootNode(node.actualNode)
 			};
 		});
 	return documents;
@@ -188,34 +243,53 @@ axe.utils.preloadCssom = function preloadCssom({
 
 	/**
 	 * Convert text content to CSSStyleSheet
-	 * @method convertTextToStylesheet
+	 * @method getStyleSheet
 	 * @private
-	 * @param {Object} param an object with properties to construct stylesheet
-	 * @property {String} param.data text content of the stylesheet
-	 * @property {Boolean} param.isExternal flag to notify if the resource was fetched from the network
-	 * @property {Object} param.doc implementation document to create style elements
-	 * @property {String} param.shadowId (Optional) shadowId if shadowDOM
+	 * @param {Object} arg an object with properties to construct stylesheet
+	 * @property {String} arg.data text content of the stylesheet
+	 * @property {Boolean} arg.isExternal flag to notify if the resource was fetched from the network
+	 * @property {String} arg.shadowId (Optional) shadowId if shadowDOM
+	 * @property {Object} arg.root implementation document to create style elements
+	 * @property {String} arg.priority a number indicating the loaded priority of CSS, to denote specificity of styles contained in the sheet.
 	 */
-	function convertTextToStylesheet({ data, isExternal, shadowId, root }) {
+	function getStyleSheet({
+		data,
+		isExternal,
+		shadowId,
+		root,
+		priority,
+		isLink = false
+	}) {
 		const style = dynamicDoc.createElement('style');
-		style.type = 'text/css';
-		style.appendChild(dynamicDoc.createTextNode(data));
+		if (isLink) {
+			// as creating a stylesheet as link will need to be awaited
+			// till `onload`, it is wise to convert link href to @import statement
+			const text = dynamicDoc.createTextNode(`@import "${data.href}"`);
+			style.appendChild(text);
+		} else {
+			style.appendChild(dynamicDoc.createTextNode(data));
+		}
 		dynamicDoc.head.appendChild(style);
 		return {
 			sheet: style.sheet,
 			isExternal,
 			shadowId,
-			root
+			root,
+			priority
 		};
 	}
 
 	q.defer((resolve, reject) => {
-		// as there can be multiple documents (root document, shadow document fragments, and frame documents)
-		// reduce these into a queue
 		roots
-			.reduce((out, root) => {
+			.reduce((out, root, index) => {
 				out.defer((resolve, reject) => {
-					loadCssom(root, timeout, convertTextToStylesheet)
+					loadCssom({
+						rootNode: root.rootNode,
+						rootIndex: index + 1, // we want index to start with 1 for priority calculation
+						shadowId: root.shadowId,
+						timeout,
+						getStyleSheet
+					})
 						.then(resolve)
 						.catch(reject);
 				});
diff --git a/test/core/utils/preload-cssom.js b/test/core/utils/preload-cssom.js
index 53c32b8135..fb051175b4 100644
--- a/test/core/utils/preload-cssom.js
+++ b/test/core/utils/preload-cssom.js
@@ -63,7 +63,13 @@ describe('axe.utils.preloadCssom unit tests', function() {
 				var cssom = results[0];
 				assert.lengthOf(cssom, 2);
 				cssom.forEach(function(o) {
-					assert.hasAllKeys(o, ['root', 'shadowId', 'sheet', 'isExternal']);
+					assert.hasAllKeys(o, [
+						'root',
+						'shadowId',
+						'sheet',
+						'isExternal',
+						'priority'
+					]);
 				});
 				done();
 			})
diff --git a/test/integration/full/css-orientation-lock/violations.js b/test/integration/full/css-orientation-lock/violations.js
index 760f2cccc7..8e0a72fb0f 100644
--- a/test/integration/full/css-orientation-lock/violations.js
+++ b/test/integration/full/css-orientation-lock/violations.js
@@ -39,6 +39,14 @@ describe('css-orientation-lock violations test', function() {
 		}
 	});
 
+	function assertViolatedSelectors(relatedNodes, violatedSelectors) {
+		relatedNodes.forEach(function(node) {
+			var target = node.target[0];
+			var className = Array.isArray(target) ? target.reverse()[0] : target;
+			assert.isTrue(violatedSelectors.indexOf(className) !== -1);
+		});
+	}
+
 	it('returns VIOLATIONS if preload is set to TRUE', function(done) {
 		// the sheets included in the html, have styles for transform and rotate, hence the violation
 		axe.run(
@@ -57,18 +65,17 @@ describe('css-orientation-lock violations test', function() {
 				assert.property(res, 'violations');
 				assert.lengthOf(res.violations, 1);
 
-				// assert the node and related nodes
+				// assert the node
 				var checkedNode = res.violations[0].nodes[0];
 				assert.isTrue(/html/i.test(checkedNode.html));
 
+				// assert the relatedNodes
 				var checkResult = checkedNode.all[0];
 				assert.lengthOf(checkResult.relatedNodes, 2);
-				var violatedSelectors = ['.someDiv', '.thatDiv'];
-				checkResult.relatedNodes.forEach(function(node) {
-					var target = node.target[0];
-					var className = Array.isArray(target) ? target.reverse()[0] : target;
-					assert.isTrue(violatedSelectors.indexOf(className) !== -1);
-				});
+				assertViolatedSelectors(checkResult.relatedNodes, [
+					'.someDiv',
+					'.thatDiv'
+				]);
 
 				done();
 			}
@@ -101,12 +108,19 @@ describe('css-orientation-lock violations test', function() {
 					assert.property(res, 'violations');
 					assert.lengthOf(res.violations, 1);
 
-					// assert the node and related nodes
+					// assert the node
 					var checkedNode = res.violations[0].nodes[0];
+					assert.isTrue(/html/i.test(checkedNode.html));
+
+					// assert the relatedNodes
 					var checkResult = checkedNode.all[0];
+					assert.lengthOf(checkResult.relatedNodes, 3);
+					assertViolatedSelectors(checkResult.relatedNodes, [
+						'.someDiv',
+						'.thatDiv',
+						'.shadowDiv'
+					]);
 
-					// Issue - https://github.com/dequelabs/axe-core/issues/1082
-					assert.isAtLeast(checkResult.relatedNodes.length, 2);
 					done();
 				}
 			);
diff --git a/test/integration/full/preload-cssom/preload-cssom.html b/test/integration/full/preload-cssom/preload-cssom.html
index f3cb326d13..4939a3c154 100644
--- a/test/integration/full/preload-cssom/preload-cssom.html
+++ b/test/integration/full/preload-cssom/preload-cssom.html
@@ -17,7 +17,6 @@
 <body>
 	<iframe id="frame1" src="frames/level1.html"></iframe>
 	<div id="mocha"></div>
-	<div id="shadow-fixture"></div>
 	<div class="blue">blue on parent page</div>
 	<script src="/test/testutils.js"></script>
 	<script src="preload-cssom.js"></script>
diff --git a/test/integration/full/preload-cssom/preload-cssom.js b/test/integration/full/preload-cssom/preload-cssom.js
index 635357b8c4..4274750187 100644
--- a/test/integration/full/preload-cssom/preload-cssom.js
+++ b/test/integration/full/preload-cssom/preload-cssom.js
@@ -164,12 +164,27 @@ describe('preload cssom integration test', function() {
 	});
 
 	describe('tests for current top level document', function() {
+		var shadowFixture;
+
 		before(function() {
 			if (isPhantom) {
 				this.skip();
 			}
 		});
 
+		beforeEach(function() {
+			var shadowNode = document.createElement('div');
+			shadowNode.id = 'shadow-fixture';
+			document.body.appendChild(shadowNode);
+			shadowFixture = document.getElementById('shadow-fixture');
+		});
+
+		afterEach(function() {
+			if (shadowFixture) {
+				document.body.removeChild(shadowFixture);
+			}
+		});
+
 		it('should return inline stylesheets defined using <style> tag', function(done) {
 			getPreload()
 				.then(function(results) {
@@ -222,22 +237,70 @@ describe('preload cssom integration test', function() {
 		});
 
 		(shadowSupported ? it : xit)(
-			'should return styles from shadow dom',
+			'should return styles from shadow dom (handles @import "external", @import "relative" and inline styles)',
+			function(done) {
+				var shadow = shadowFixture.attachShadow({ mode: 'open' });
+				shadow.innerHTML =
+					'<style> @import "https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.css"; @import "preload-cssom-shadow-blue.css"; .green { background-color: green; } </style>' +
+					'<div class="initialism">Some text</div>' +
+					'<div class="green">green</div>' +
+					'<div class="red">red</div>' +
+					'<h1>Heading</h1>';
+				getPreload(shadowFixture)
+					.then(function(results) {
+						var sheets = results[0];
+						// verify count
+						assert.lengthOf(sheets, 7);
+						// verify that the last non external sheet with shadowId has green selector
+						var nonExternalsheetsWithShadowId = sheets
+							.filter(function(s) {
+								return !s.isExternal;
+							})
+							.filter(function(s) {
+								return s.shadowId;
+							});
+						assertStylesheet(
+							nonExternalsheetsWithShadowId[
+								nonExternalsheetsWithShadowId.length - 1
+							].sheet,
+							'.green',
+							'.green{background-color:green;}'
+						);
+						// verify priority of shadowId sheets is higher than base document
+						var anySheetFromBaseDocument = sheets.filter(function(s) {
+							return !s.shadowId;
+						})[0];
+						var anySheetFromShadowDocument = sheets.filter(function(s) {
+							return s.shadowId;
+						})[0];
+						// shadow dom priority is greater than base doc
+						assert.isAbove(
+							anySheetFromShadowDocument.priority[0],
+							anySheetFromBaseDocument.priority[0]
+						);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		(shadowSupported ? it : xit)(
+			'should return styles from shadow dom (handles multiple <style> declarations with @import "external", @import "relative" and inline styles)',
 			function(done) {
-				var fixture = document.getElementById('shadow-fixture');
-				var shadow = fixture.attachShadow({ mode: 'open' });
+				var shadow = shadowFixture.attachShadow({ mode: 'open' });
 				shadow.innerHTML =
-					'<style>@import "https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.css"; @import "preload-cssom-shadow-blue.css"; .green { background-color: green; }</style>' +
+					'<style> @import "https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.css"; @import "preload-cssom-shadow-blue.css"; .green { background-color: green; } </style>' +
 					'<div class="initialism">Some text</div>' +
+					'<style> .notGreen { background-color: orange; } </style>' +
 					'<div class="green">green</div>' +
 					'<div class="red">red</div>' +
-					'' +
+					'<div class="notGreen">red</div>' +
 					'<h1>Heading</h1>';
-				getPreload(fixture)
+				getPreload(shadowFixture)
 					.then(function(results) {
 						var sheets = results[0];
 						// verify count
-						assert.isAtLeast(sheets.length, 4);
+						assert.lengthOf(sheets, 8);
 						// verify that the last non external sheet with shadowId has green selector
 						var nonExternalsheetsWithShadowId = sheets
 							.filter(function(s) {
@@ -246,20 +309,65 @@ describe('preload cssom integration test', function() {
 							.filter(function(s) {
 								return s.shadowId;
 							});
+						assertStylesheet(
+							nonExternalsheetsWithShadowId[
+								nonExternalsheetsWithShadowId.length - 2
+							].sheet,
+							'.green',
+							'.green{background-color:green;}'
+						);
+						assertStylesheet(
+							nonExternalsheetsWithShadowId[
+								nonExternalsheetsWithShadowId.length - 1
+							].sheet,
+							'.notGreen',
+							'.notGreen{background-color:orange;}'
+						);
+						done();
+					})
+					.catch(done);
+			}
+		);
+
+		(shadowSupported ? it : xit)(
+			'should return styles from shadow dom (handles mulitple <style> and <link> tags)',
+			function(done) {
+				var shadow = shadowFixture.attachShadow({ mode: 'open' });
+				shadow.innerHTML =
+					'<style> @import "https://cdnjs.cloudflare.com/ajax/libs/skeleton/2.0.4/skeleton.css"; </style>' +
+					'<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/pure/1.0.0/pure.css" />' +
+					'<h1>Heading</h1>';
+				getPreload(shadowFixture)
+					.then(function(results) {
+						var sheets = results[0];
+						// verify count
+						assert.lengthOf(sheets, 6);
+
+						// verify that the last non external sheet with shadowId has green selector
+						var nonExternalsheetsWithShadowId = sheets
+							.filter(function(s) {
+								return !s.isExternal;
+							})
+							.filter(function(s) {
+								return s.shadowId;
+							});
+						// there are no inline styles in shadowRoot
+						assert.lengthOf(nonExternalsheetsWithShadowId, 0);
+
+						// ensure the output of shadowRoot sheet is that of expected external mocked response
+						var externalsheetsWithShadowId = sheets
+							.filter(function(s) {
+								return s.isExternal;
+							})
+							.filter(function(s) {
+								return s.shadowId;
+							});
+						assertStylesheet(
+							externalsheetsWithShadowId[0].sheet,
+							'body',
+							'body{overflow:auto;}'
+						);
 
-						// Issue - https://github.com/dequelabs/axe-core/issues/1082
-						if (
-							nonExternalsheetsWithShadowId &&
-							nonExternalsheetsWithShadowId.length
-						) {
-							assertStylesheet(
-								nonExternalsheetsWithShadowId[
-									nonExternalsheetsWithShadowId.length - 1
-								].sheet,
-								'.green',
-								'.green{background-color:green;}'
-							);
-						}
 						done();
 					})
 					.catch(done);