diff --git a/includes/class-amp-theme-support.php b/includes/class-amp-theme-support.php
index 54b8da57064..2ecb8ebc9dc 100644
--- a/includes/class-amp-theme-support.php
+++ b/includes/class-amp-theme-support.php
@@ -1058,7 +1058,7 @@ public static function prepare_response( $response, $args = array() ) {
 				'allow_dirty_styles'      => self::is_customize_preview_iframe(), // Dirty styles only needed when editing (e.g. for edit shortcodes).
 				'allow_dirty_scripts'     => is_customize_preview(), // Scripts are always needed to inject changeset UUID.
 				'enable_response_caching' => (
-					( ! defined( 'WP_DEBUG' ) || true !== WP_DEBUG )
+					! ( defined( 'WP_DEBUG' ) && WP_DEBUG )
 					&&
 					! AMP_Validation_Manager::should_validate_response()
 				),
@@ -1080,8 +1080,20 @@ public static function prepare_response( $response, $args = array() ) {
 
 			$response_cache = wp_cache_get( $response_cache_key, self::RESPONSE_CACHE_GROUP );
 
-			if ( ! empty( $response_cache ) ) {
-				return $response_cache;
+			// Make sure that all of the validation errors should be sanitized in the same way; if not, then the cached body should be discarded.
+			if ( isset( $response_cache['validation_results'] ) ) {
+				foreach ( $response_cache['validation_results'] as $validation_result ) {
+					$should_sanitize = AMP_Validation_Error_Taxonomy::is_validation_error_sanitized( $validation_result['error'] );
+					if ( $should_sanitize !== $validation_result['sanitized'] ) {
+						unset( $response_cache['body'] );
+						break;
+					}
+				}
+			}
+
+			// Short-circuit response with cached body.
+			if ( isset( $response_cache['body'] ) ) {
+				return $response_cache['body'];
 			}
 		}
 
@@ -1102,14 +1114,13 @@ public static function prepare_response( $response, $args = array() ) {
 				1
 			);
 		}
-		$dom = AMP_DOM_Utils::get_dom( $response );
-
-		$xpath = new DOMXPath( $dom );
 
+		$dom  = AMP_DOM_Utils::get_dom( $response );
 		$head = $dom->getElementsByTagName( 'head' )->item( 0 );
 
+		// Make sure scripts from the body get moved to the head.
 		if ( isset( $head ) ) {
-			// Make sure scripts from the body get moved to the head.
+			$xpath = new DOMXPath( $dom );
 			foreach ( $xpath->query( '//body//script[ @custom-element or @custom-template ]' ) as $script ) {
 				$head->appendChild( $script );
 			}
@@ -1208,7 +1219,17 @@ public static function prepare_response( $response, $args = array() ) {
 
 		// Cache response if enabled.
 		if ( true === $args['enable_response_caching'] ) {
-			wp_cache_set( $response_cache_key, $response, self::RESPONSE_CACHE_GROUP, MONTH_IN_SECONDS );
+			$response_cache = array(
+				'body'               => $response,
+				'validation_results' => array_map(
+					function( $result ) {
+						unset( $result['error']['sources'] );
+						return $result;
+					},
+					AMP_Validation_Manager::$validation_results
+				),
+			);
+			wp_cache_set( $response_cache_key, $response_cache, self::RESPONSE_CACHE_GROUP, MONTH_IN_SECONDS );
 		}
 
 		return $response;
diff --git a/includes/validation/class-amp-invalid-url-post-type.php b/includes/validation/class-amp-invalid-url-post-type.php
index 665068fffc9..8504a36ffce 100644
--- a/includes/validation/class-amp-invalid-url-post-type.php
+++ b/includes/validation/class-amp-invalid-url-post-type.php
@@ -177,7 +177,7 @@ public static function add_admin_menu_new_invalid_url_count() {
 	 *
 	 *     @type bool $ignore_accepted Exclude validation errors that are accepted. Default false.
 	 * }
-	 * @return array List of errors.
+	 * @return array List of errors, with keys for term, data, status, and (sanitization) forced.
 	 */
 	public static function get_invalid_url_validation_errors( $post, $args = array() ) {
 		$args   = array_merge(
@@ -198,20 +198,18 @@ public static function get_invalid_url_validation_errors( $post, $args = array()
 				continue;
 			}
 			$term = get_term_by( 'slug', $stored_validation_error['term_slug'], AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
-			if ( ! $term ) {
-				continue;
-			}
-			if ( $args['ignore_accepted'] && AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $term->term_group ) {
+
+			$sanitization = AMP_Validation_Error_Taxonomy::get_validation_error_sanitization( $stored_validation_error['data'] );
+			if ( $args['ignore_accepted'] && AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $sanitization['status'] ) {
 				continue;
 			}
-			$errors[] = array(
-				'term' => $term,
-				'data' => array_merge(
-					json_decode( $term->description, true ),
-					array(
-						'sources' => $stored_validation_error['sources'],
-					)
+
+			$errors[] = array_merge(
+				array(
+					'term' => $term,
+					'data' => $stored_validation_error['data'],
 				),
+				$sanitization
 			);
 		}
 		return $errors;
@@ -234,10 +232,8 @@ public static function get_invalid_url_validation_error_counts( $post ) {
 		);
 
 		$validation_errors = self::get_invalid_url_validation_errors( $post );
-		foreach ( wp_list_pluck( $validation_errors, 'term' ) as $term ) {
-			if ( isset( $counts[ $term->term_group ] ) ) {
-				$counts[ $term->term_group ]++;
-			}
+		foreach ( $validation_errors as $error ) {
+			$counts[ $error['status'] ]++;
 		}
 		return $counts;
 	}
@@ -318,15 +314,6 @@ public static function store_validation_errors( $validation_errors, $url ) {
 
 		$terms = array();
 		foreach ( $validation_errors as $data ) {
-			/*
-			 * Exclude sources from data since not available unless sources are being obtained,
-			 * and thus not able to be matched when hashed.
-			 */
-			$sources = null;
-			if ( isset( $data['sources'] ) ) {
-				$sources = $data['sources'];
-			}
-
 			$term_data = AMP_Validation_Error_Taxonomy::prepare_validation_error_taxonomy_term( $data );
 			$term_slug = $term_data['slug'];
 			if ( ! isset( $terms[ $term_slug ] ) ) {
@@ -352,7 +339,7 @@ public static function store_validation_errors( $validation_errors, $url ) {
 				$terms[ $term_slug ] = $term;
 			}
 
-			$stored_validation_errors[] = compact( 'term_slug', 'sources' );
+			$stored_validation_errors[] = compact( 'term_slug', 'data' );
 		}
 
 		$post_content = wp_json_encode( $stored_validation_errors );
@@ -627,13 +614,11 @@ public static function filter_row_actions( $actions, $post ) {
 		$view_url        = add_query_arg( AMP_Validation_Manager::VALIDATE_QUERY_VAR, '', $url ); // Prevent redirection to non-AMP page.
 		$actions['view'] = sprintf( '<a href="%s">%s</a>', esc_url( $view_url ), esc_html__( 'View', 'amp' ) );
 
-		if ( ! empty( $url ) ) {
-			$actions[ self::RECHECK_ACTION ] = sprintf(
-				'<a href="%s">%s</a>',
-				self::get_recheck_url( $post, get_edit_post_link( $post->ID, 'raw' ), $url ),
-				esc_html__( 'Re-check', 'amp' )
-			);
-		}
+		$actions[ self::RECHECK_ACTION ] = sprintf(
+			'<a href="%s">%s</a>',
+			esc_url( self::get_recheck_url( $post, get_edit_post_link( $post->ID, 'raw' ) ) ),
+			esc_html__( 'Re-check', 'amp' )
+		);
 
 		return $actions;
 	}
@@ -708,9 +693,9 @@ public static function print_admin_notice() {
 			$errors_remain     = ! empty( $_GET[ self::REMAINING_ERRORS ] ); // WPCS: CSRF ok.
 			if ( $errors_remain ) {
 				$class   = 'notice-warning';
-				$message = _n( 'The rechecked URL still has validation errors.', 'The rechecked URLs still have validation errors.', $count_urls_tested, 'amp' );
+				$message = _n( 'The rechecked URL still has blocking validation errors.', 'The rechecked URLs still have validation errors.', $count_urls_tested, 'amp' );
 			} else {
-				$message = _n( 'The rechecked URL has no validation errors.', 'The rechecked URLs have no validation errors.', $count_urls_tested, 'amp' );
+				$message = _n( 'The rechecked URL has no blocking validation errors.', 'The rechecked URLs have no validation errors.', $count_urls_tested, 'amp' );
 				$class   = 'updated';
 			}
 
@@ -722,8 +707,8 @@ public static function print_admin_notice() {
 			);
 		}
 
-		if ( isset( $_GET['amp_taxonomy_terms_updated'] ) ) { // WPCS: CSRF ok.
-			$count = intval( $_GET['amp_taxonomy_terms_updated'] );
+		$count = isset( $_GET['amp_taxonomy_terms_updated'] ) ? intval( $_GET['amp_taxonomy_terms_updated'] ) : 0; // WPCS: CSRF ok.
+		if ( $count > 0 ) {
 			$class = 'updated';
 			printf(
 				'<div class="notice is-dismissible %s"><p>%s</p><button type="button" class="notice-dismiss"><span class="screen-reader-text">%s</span></button></div>',
@@ -751,20 +736,14 @@ public static function print_admin_notice() {
 	 */
 	public static function handle_inline_recheck( $post_id ) {
 		check_admin_referer( self::NONCE_ACTION . $post_id );
-		$post = get_post( $post_id );
-		$url  = $post->post_title;
-		if ( isset( $_GET['recheck_url'] ) ) {
-			$url = wp_validate_redirect( wp_unslash( $_GET['recheck_url'] ) );
-		}
-		$validation_errors = AMP_Validation_Manager::validate_url( $url );
-		$remaining_errors  = true;
-		if ( is_array( $validation_errors ) ) {
-			self::store_validation_errors( $validation_errors, $url );
-			$remaining_errors = ! empty( $validation_errors );
-		}
+		$validation_results = self::recheck_post( $post_id );
 
 		$redirect = wp_get_referer();
-		if ( ! $redirect || empty( $validation_errors ) ) {
+		if ( $redirect ) {
+			$redirect = remove_query_arg( wp_removable_query_args(), $redirect );
+		}
+
+		if ( ! $redirect || is_wp_error( $validation_results ) || empty( $validation_results ) ) {
 			// If there are no remaining errors and the post was deleted, redirect to edit.php instead of post.php.
 			$redirect = add_query_arg(
 				'post_type',
@@ -773,13 +752,48 @@ public static function handle_inline_recheck( $post_id ) {
 			);
 		}
 		$args = array(
-			self::URLS_TESTED      => '1',
-			self::REMAINING_ERRORS => $remaining_errors ? '1' : '0',
+			self::URLS_TESTED => '1',
 		);
+
+		// @todo For WP_Error case, see <https://github.com/Automattic/amp-wp/issues/1166>.
+		if ( ! is_wp_error( $validation_results ) ) {
+			$args[ self::REMAINING_ERRORS ] = count( array_filter(
+				$validation_results,
+				function( $result ) {
+					return ! $result['sanitized'];
+				}
+			) );
+		}
+
 		wp_safe_redirect( add_query_arg( $args, $redirect ) );
 		exit();
 	}
 
+	/**
+	 * Re-check invalid URL post for whether it has blocking validation errors.
+	 *
+	 * @param int|WP_Post $post Post.
+	 * @return array|WP_Error List of blocking validation resukts, or a WP_Error in the case of failure.
+	 */
+	public static function recheck_post( $post ) {
+		$post = get_post( $post );
+		$url  = $post->post_title;
+
+		$validation_errors = AMP_Validation_Manager::validate_url( $url );
+		if ( is_wp_error( $validation_errors ) ) {
+			return $validation_errors;
+		}
+
+		$validation_results = array();
+		self::store_validation_errors( $validation_errors, $url );
+		foreach ( $validation_errors as $error ) {
+			$sanitized = AMP_Validation_Error_Taxonomy::is_validation_error_sanitized( $error );
+
+			$validation_results[] = compact( 'error', 'sanitized' );
+		}
+		return $validation_results;
+	}
+
 	/**
 	 * Handle validation error status update.
 	 *
@@ -792,6 +806,10 @@ public static function handle_validation_error_status_update() {
 		if ( empty( $_POST[ AMP_Validation_Manager::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR ] ) || ! is_array( $_POST[ AMP_Validation_Manager::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR ] ) ) {
 			return;
 		}
+		$post = get_post();
+		if ( ! $post || self::POST_TYPE_SLUG !== $post->post_type ) {
+			return;
+		}
 		$updated_count = 0;
 
 		$has_pre_term_description_filter = has_filter( 'pre_term_description', 'wp_filter_kses' );
@@ -819,7 +837,32 @@ public static function handle_validation_error_status_update() {
 		$args = array(
 			'amp_taxonomy_terms_updated' => $updated_count,
 		);
-		wp_safe_redirect( add_query_arg( $args, wp_get_referer() ) );
+
+		/*
+		 * Re-check the post after the validation status change. This is particularly important for validation errors like
+		 * 'removed_unused_css_rules' since whether it is accepted will determine whether other validation errors are triggered
+		 * such as in this case 'excessive_css'.
+		 */
+		if ( $updated_count > 0 ) {
+			$validation_results = self::recheck_post( $post->ID );
+			// @todo For WP_Error case, see <https://github.com/Automattic/amp-wp/issues/1166>.
+			if ( ! is_wp_error( $validation_results ) ) {
+				$args[ self::REMAINING_ERRORS ] = count( array_filter(
+					$validation_results,
+					function( $result ) {
+						return ! $result['sanitized'];
+					}
+				) );
+			}
+		}
+
+		$redirect = wp_get_referer();
+		if ( ! $redirect ) {
+			$redirect = get_edit_post_link( $post->ID );
+		}
+
+		$redirect = remove_query_arg( wp_removable_query_args(), $redirect );
+		wp_safe_redirect( add_query_arg( $args, $redirect ) );
 		exit();
 	}
 
@@ -921,7 +964,7 @@ public static function print_validation_errors_meta_box( $post ) {
 		$validation_errors = self::get_invalid_url_validation_errors( $post );
 
 		$can_serve_amp = 0 === count( array_filter( $validation_errors, function( $validation_error ) {
-			return AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS !== $validation_error['term']->term_group;
+			return AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS !== $validation_error['status'];
 		} ) );
 		?>
 		<style>
@@ -966,6 +1009,22 @@ public static function print_validation_errors_meta_box( $post ) {
 		} );
 		</script>
 
+		<?php
+		$has_forced_sanitized = false;
+		foreach ( $validation_errors as $validation_error ) {
+			if ( $validation_error['forced'] ) {
+				$has_forced_sanitized = true;
+				break;
+			}
+		}
+		?>
+
+		<?php if ( $has_forced_sanitized ) : ?>
+			<div class="notice notice-info notice-alt inline">
+				<p><?php esc_html_e( 'This site is configured to automatically decide whether or not some validation errors may be accepted. For these errors, you cannot change their status below.', 'amp' ); ?></p>
+			</div>
+		<?php endif; ?>
+
 		<div class="amp-validation-errors">
 			<ul>
 				<?php foreach ( $validation_errors as $error ) : ?>
@@ -975,23 +1034,23 @@ public static function print_validation_errors_meta_box( $post ) {
 					$select_name       = sprintf( '%s[%s]', AMP_Validation_Manager::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR, $term->slug );
 					?>
 					<li>
-						<details <?php echo ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $term->term_group ) ? 'open' : ''; ?>>
+						<details <?php echo ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $error['status'] ) ? 'open' : ''; ?>>
 							<summary>
 								<label for="<?php echo esc_attr( $select_name ); ?>" class="screen-reader-text">
 									<?php esc_html_e( 'Status:', 'amp' ); ?>
 								</label>
-								<select class="amp-validation-error-status" id="<?php echo esc_attr( $select_name ); ?>" name="<?php echo esc_attr( $select_name ); ?>">
-									<?php if ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $term->term_group ) : ?>
+								<select class="amp-validation-error-status" id="<?php echo esc_attr( $select_name ); ?>" name="<?php echo esc_attr( $select_name ); ?>" <?php disabled( $error['forced'] ); ?>>
+									<?php if ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $error['status'] ) : ?>
 										<option value=""><?php esc_html_e( 'New', 'amp' ); ?></option>
 									<?php endif; ?>
-									<option value="<?php echo esc_attr( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS ); ?>" <?php selected( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS, $term->term_group ); ?>><?php esc_html_e( 'Accepted', 'amp' ); ?></option>
-									<option value="<?php echo esc_attr( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS ); ?>" <?php selected( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS, $term->term_group ); ?>><?php esc_html_e( 'Rejected', 'amp' ); ?></option>
+									<option value="<?php echo esc_attr( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS ); ?>" <?php selected( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS, $error['status'] ); ?>><?php esc_html_e( 'Accepted', 'amp' ); ?></option>
+									<option value="<?php echo esc_attr( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS ); ?>" <?php selected( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS, $error['status'] ); ?>><?php esc_html_e( 'Rejected', 'amp' ); ?></option>
 								</select>
-								<?php if ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $term->term_group ) : ?>
+								<?php if ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $error['status'] ) : ?>
 									&#x2753;
-								<?php elseif ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS === $term->term_group ) : ?>
+								<?php elseif ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS === $error['status'] ) : ?>
 									&#x274C;
-								<?php elseif ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $term->term_group ) : ?>
+								<?php elseif ( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $error['status'] ) : ?>
 									&#x2705;
 								<?php endif; ?>
 								<code><?php echo esc_html( $error['data']['code'] ); ?></code>
@@ -1147,15 +1206,13 @@ public static function filter_the_title_in_post_list_table( $title, $post ) {
 	 *
 	 * @param  WP_Post $post         The post storing the validation error.
 	 * @param  string  $redirect_url The URL of the redirect.
-	 * @param  string  $recheck_url  The URL to check. Optional.
 	 * @return string The URL to recheck the post.
 	 */
-	public static function get_recheck_url( $post, $redirect_url, $recheck_url = null ) {
+	public static function get_recheck_url( $post, $redirect_url ) {
 		return wp_nonce_url(
 			add_query_arg(
 				array(
-					'action'      => self::RECHECK_ACTION,
-					'recheck_url' => $recheck_url,
+					'action' => self::RECHECK_ACTION,
 				),
 				$redirect_url
 			),
diff --git a/includes/validation/class-amp-validation-error-taxonomy.php b/includes/validation/class-amp-validation-error-taxonomy.php
index 880f97efda1..381e415ca4d 100644
--- a/includes/validation/class-amp-validation-error-taxonomy.php
+++ b/includes/validation/class-amp-validation-error-taxonomy.php
@@ -178,6 +178,74 @@ public static function prepare_validation_error_taxonomy_term( $error ) {
 		);
 	}
 
+
+	/**
+	 * Determine whether a validation error should be sanitized.
+	 *
+	 * @param array $error Validation error.
+	 *
+	 * @return bool Whether error should be sanitized.
+	 */
+	public static function is_validation_error_sanitized( $error ) {
+		$sanitization = self::get_validation_error_sanitization( $error );
+		return self::VALIDATION_ERROR_ACCEPTED_STATUS === $sanitization['status'];
+	}
+
+	/**
+	 * Get the validation error sanitization.
+	 *
+	 * @param array $error Validation error.
+	 *
+	 * @return array {
+	 *     Validation error sanitization.
+	 *
+	 *     @type int  $status Validation status (0=VALIDATION_ERROR_NEW_STATUS, 1=VALIDATION_ERROR_ACCEPTED_STATUS, 2=VALIDATION_ERROR_REJECTED_STATUS).
+	 *     @type bool $forced Whether sanitization is forced via filter.
+	 * }
+	 */
+	public static function get_validation_error_sanitization( $error ) {
+		$term_data = self::prepare_validation_error_taxonomy_term( $error );
+		$term      = get_term_by( 'slug', $term_data['slug'], self::TAXONOMY_SLUG );
+		$statuses  = array(
+			self::VALIDATION_ERROR_NEW_STATUS,
+			self::VALIDATION_ERROR_ACCEPTED_STATUS,
+			self::VALIDATION_ERROR_REJECTED_STATUS,
+		);
+		if ( isset( AMP_Validation_Manager::$validation_error_status_overrides[ $term_data['slug'] ] ) ) {
+			// See note in AMP_Validation_Manager::add_validation_error_sourcing() for why amp_validation_error_sanitized filter isn't used.
+			$status = AMP_Validation_Manager::$validation_error_status_overrides[ $term_data['slug'] ];
+		} elseif ( ! empty( $term ) && in_array( $term->term_group, $statuses, true ) ) {
+			$status = $term->term_group;
+		} else {
+			$status = self::VALIDATION_ERROR_NEW_STATUS;
+		}
+
+		/**
+		 * Filters whether the validation error should be sanitized.
+		 *
+		 * Note that the $node is not passed here to ensure that the filter can be
+		 * applied on validation errors that have been stored. Likewise, the $sources
+		 * are also omitted because these are only available during an explicit
+		 * validation request and so they are not suitable for plugins to vary
+		 * sanitization by. Note that returning false this indicates that the
+		 * validation error should not be considered a blocker to render AMP.
+		 *
+		 * @since 1.0
+		 *
+		 * @param null|bool $sanitized Whether sanitized; this is initially null, and changing it to bool causes the validation error to be forced.
+		 * @param array $error Validation error being sanitized.
+		 */
+		$sanitized = apply_filters( 'amp_validation_error_sanitized', null, $error );
+
+		$forced = false;
+		if ( null !== $sanitized ) {
+			$forced = true;
+			$status = $sanitized ? self::VALIDATION_ERROR_ACCEPTED_STATUS : self::VALIDATION_ERROR_REJECTED_STATUS;
+		}
+
+		return compact( 'status', 'forced' );
+	}
+
 	/**
 	 * Get the count of validation error terms, optionally restricted by term group (e.g. accepted or rejected).
 	 *
@@ -281,7 +349,7 @@ public static function summarize_validation_errors( $validation_errors ) {
 			}
 
 			if ( ! empty( $validation_error['sources'] ) ) {
-				$source = array_pop( $validation_error['sources'] );
+				$source = array_shift( $validation_error['sources'] );
 
 				if ( isset( $source['type'], $source['name'] ) ) {
 					$invalid_sources[ $source['type'] ][] = $source['name'];
@@ -308,6 +376,9 @@ public static function summarize_validation_errors( $validation_errors ) {
 	 */
 	public static function add_admin_hooks() {
 		add_action( 'load-edit-tags.php', array( __CLASS__, 'add_group_terms_clauses_filter' ) );
+		add_action( 'load-edit-tags.php', function() {
+			add_filter( 'user_has_cap', array( __CLASS__, 'filter_user_has_cap_for_hiding_term_list_table_checkbox' ), 10, 3 );
+		} );
 		add_filter( 'terms_clauses', array( __CLASS__, 'filter_terms_clauses_for_description_search' ), 10, 3 );
 		add_action( 'admin_notices', array( __CLASS__, 'add_admin_notices' ) );
 		add_filter( 'tag_row_actions', array( __CLASS__, 'filter_tag_row_actions' ), 10, 2 );
@@ -428,6 +499,35 @@ public static function add_group_terms_clauses_filter() {
 		}, 10, 2 );
 	}
 
+	/**
+	 * Prevent user from being able to delete validation errors in order to disable the checkbox on the post list table.
+	 *
+	 * Yes, this is not ideal.
+	 *
+	 * @param array $allcaps All caps.
+	 * @param array $caps    Requested caps.
+	 * @param array $args    Cap args.
+	 * @return array All caps.
+	 */
+	public static function filter_user_has_cap_for_hiding_term_list_table_checkbox( $allcaps, $caps, $args ) {
+		if ( isset( $args[0] ) && 'delete_term' === $args[0] ) {
+			$term  = get_term( $args[2] );
+			$error = json_decode( $term->description, true );
+			if ( ! is_array( $error ) ) {
+				return $allcaps;
+			}
+
+			$sanitization = self::get_validation_error_sanitization( $error );
+			if ( $sanitization['forced'] ) {
+				$allcaps = array_merge(
+					$allcaps,
+					array_fill_keys( $caps, false )
+				);
+			}
+		}
+		return $allcaps;
+	}
+
 	/**
 	 * Include searching taxonomy term descriptions and sources term meta.
 	 *
@@ -497,37 +597,41 @@ public static function add_admin_notices() {
 	public static function filter_tag_row_actions( $actions, WP_Term $tag ) {
 		if ( self::TAXONOMY_SLUG === $tag->taxonomy ) {
 			$term_id = $tag->term_id;
+			$term    = get_term( $tag->term_id ); // We don't want filter=display given by $tag.
 
 			/*
 			 * Hide deletion link since a validation error should only be removed once
-			 * it no longer has an occurence on the site. When an invalid URL is re-checked
+			 * it no longer has an occurrence on the site. When an invalid URL is re-checked
 			 * and it no longer has this validation error, then the count will be decremented.
 			 * When a validation error term no longer has a count, then it is hidden from the
 			 * list table. A cron job could periodically delete terms that have no counts.
 			 */
 			unset( $actions['delete'] );
 
-			if ( self::VALIDATION_ERROR_REJECTED_STATUS !== $tag->term_group ) {
-				$actions[ self::VALIDATION_ERROR_REJECT_ACTION ] = sprintf(
-					'<a href="%s" aria-label="%s">%s</a>',
-					wp_nonce_url(
-						add_query_arg( array_merge( array( 'action' => self::VALIDATION_ERROR_REJECT_ACTION ), compact( 'term_id' ) ) ),
-						self::VALIDATION_ERROR_REJECT_ACTION
-					),
-					esc_attr__( 'Rejecting an error acknowledges that it should block a URL from being served as AMP.', 'amp' ),
-					esc_html__( 'Reject', 'amp' )
-				);
-			}
-			if ( self::VALIDATION_ERROR_ACCEPTED_STATUS !== $tag->term_group ) {
-				$actions[ self::VALIDATION_ERROR_ACCEPT_ACTION ] = sprintf(
-					'<a href="%s" aria-label="%s">%s</a>',
-					wp_nonce_url(
-						add_query_arg( array_merge( array( 'action' => self::VALIDATION_ERROR_ACCEPT_ACTION ), compact( 'term_id' ) ) ),
-						self::VALIDATION_ERROR_ACCEPT_ACTION
-					),
-					esc_attr__( 'Accepting an error means it will get sanitized and not block a URL from being served as AMP.', 'amp' ),
-					esc_html__( 'Accept', 'amp' )
-				);
+			$sanitization = self::get_validation_error_sanitization( json_decode( $term->description, true ) );
+			if ( ! $sanitization['forced'] ) {
+				if ( self::VALIDATION_ERROR_REJECTED_STATUS !== $sanitization['status'] ) {
+					$actions[ self::VALIDATION_ERROR_REJECT_ACTION ] = sprintf(
+						'<a href="%s" aria-label="%s">%s</a>',
+						wp_nonce_url(
+							add_query_arg( array_merge( array( 'action' => self::VALIDATION_ERROR_REJECT_ACTION ), compact( 'term_id' ) ) ),
+							self::VALIDATION_ERROR_REJECT_ACTION
+						),
+						esc_attr__( 'Rejecting an error acknowledges that it should block a URL from being served as AMP.', 'amp' ),
+						esc_html__( 'Reject', 'amp' )
+					);
+				}
+				if ( self::VALIDATION_ERROR_ACCEPTED_STATUS !== $sanitization['status'] ) {
+					$actions[ self::VALIDATION_ERROR_ACCEPT_ACTION ] = sprintf(
+						'<a href="%s" aria-label="%s">%s</a>',
+						wp_nonce_url(
+							add_query_arg( array_merge( array( 'action' => self::VALIDATION_ERROR_ACCEPT_ACTION ), compact( 'term_id' ) ) ),
+							self::VALIDATION_ERROR_ACCEPT_ACTION
+						),
+						esc_attr__( 'Accepting an error means it will get sanitized and not block a URL from being served as AMP.', 'amp' ),
+						esc_html__( 'Accept', 'amp' )
+					);
+				}
 			}
 		}
 		return $actions;
@@ -702,9 +806,10 @@ public static function filter_manage_custom_columns( $content, $column_name, $te
 				}
 				break;
 			case 'status':
-				if ( self::VALIDATION_ERROR_ACCEPTED_STATUS === $term->term_group ) {
+				$sanitization = self::get_validation_error_sanitization( $validation_error );
+				if ( self::VALIDATION_ERROR_ACCEPTED_STATUS === $sanitization['status'] ) {
 					$content = '&#x2705; ' . esc_html__( 'Accepted', 'amp' );
-				} elseif ( self::VALIDATION_ERROR_REJECTED_STATUS === $term->term_group ) {
+				} elseif ( self::VALIDATION_ERROR_REJECTED_STATUS === $sanitization['status'] ) {
 					$content = '&#x274C; ' . esc_html__( 'Rejected', 'amp' );
 				} else {
 					$content = '&#x2753; ' . esc_html__( 'New', 'amp' );
diff --git a/includes/validation/class-amp-validation-manager.php b/includes/validation/class-amp-validation-manager.php
index 20a3aa4a8d5..d39e7258a80 100644
--- a/includes/validation/class-amp-validation-manager.php
+++ b/includes/validation/class-amp-validation-manager.php
@@ -180,6 +180,10 @@ public static function add_validation_error_sourcing() {
 			is_array( $_REQUEST[ self::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR ] ) // WPCS: CSRF ok.
 		);
 		if ( $can_override_validation_error_statuses ) {
+			/*
+			 * This can't just easily add an amp_validation_error_sanitized filter because the the filter_sanitizer_args() method
+			 * currently needs to obtain the list of overrides to create a parsed_cache_variant.
+			 */
 			foreach ( $_REQUEST[ self::VALIDATION_ERROR_TERM_STATUS_QUERY_VAR ] as $slug => $status ) { // WPCS: CSRF ok.
 				$slug   = sanitize_key( $slug );
 				$status = intval( $status );
@@ -348,7 +352,7 @@ public static function get_amp_validity_rest_field( $post_data, $field_name, $re
 			$field['review_link'] = get_edit_post_link( $validation_status_post->ID, 'raw' );
 			foreach ( AMP_Invalid_URL_Post_Type::get_invalid_url_validation_errors( $validation_status_post ) as $result ) {
 				$field['results'][] = array(
-					'sanitized' => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $result['term']->term_group,
+					'sanitized' => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $result['status'],
 					'error'     => $result['data'],
 				);
 			}
@@ -421,37 +425,7 @@ public static function add_validation_error( array $error, array $data = array()
 		 */
 		$error = apply_filters( 'amp_validation_error', $error, compact( 'node' ) );
 
-		$term_data = AMP_Validation_Error_Taxonomy::prepare_validation_error_taxonomy_term( $error );
-
-		$term = get_term_by( 'slug', $term_data['slug'], AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
-		if ( isset( self::$validation_error_status_overrides[ $term_data['slug'] ] ) ) {
-			$sanitized = AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === self::$validation_error_status_overrides[ $term_data['slug'] ];
-		} elseif ( ! empty( $term ) && AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $term->term_group ) {
-			$sanitized = true;
-		} else {
-			$sanitized = false;
-		}
-
-		/**
-		 * Filters whether the validation error should be sanitized.
-		 *
-		 * Note that the $node is not passed here to ensure that the filter can be
-		 * applied on validation errors that have been stored. Likewise, the $sources
-		 * are also omitted because these are only available during an explicit
-		 * validation request and so they are not suitable for plugins to vary
-		 * sanitization by. Note that returning false this indicates that the
-		 * validation error should not be considered a blocker to render AMP.
-		 *
-		 * @since 1.0
-		 *
-		 * @param bool  $sanitized Whether sanitized.
-		 * @param array $context   {
-		 *     Context data for validation error sanitization.
-		 *
-		 *     @type array $error Validation error being sanitized.
-		 * }
-		 */
-		$sanitized = apply_filters( 'amp_validation_error_sanitized', $sanitized, compact( 'error' ) );
+		$sanitized = AMP_Validation_Error_Taxonomy::is_validation_error_sanitized( $error );
 
 		// Add sources back into the $error for referencing later. @todo It may be cleaner to store sources separately to avoid having to re-remove later during storage.
 		$error = array_merge( $error, compact( 'sources' ) );
diff --git a/tests/test-class-amp-theme-support.php b/tests/test-class-amp-theme-support.php
index ef3aa9455e9..049d1012473 100644
--- a/tests/test-class-amp-theme-support.php
+++ b/tests/test-class-amp-theme-support.php
@@ -1009,7 +1009,7 @@ public function test_prepare_response() {
 		ob_start();
 		?>
 		<!DOCTYPE html>
-		<html amp <?php language_attributes(); ?>>
+		<html amp>
 			<head>
 				<?php wp_head(); ?>
 				<script data-head>document.write('Illegal');</script>
@@ -1077,43 +1077,53 @@ public function test_prepare_response() {
 			$removed_nodes
 		);
 
-		$call_response = function() use ( $original_html ) {
-			return AMP_Theme_Support::prepare_response( $original_html, array(
-				'enable_response_caching' => true,
+		$prepare_response_args = array(
+			'enable_response_caching' => true,
+		);
+
+		$call_prepare_response = function() use ( $original_html, &$prepare_response_args ) {
+			AMP_Response_Headers::$headers_sent         = array();
+			AMP_Validation_Manager::$validation_results = array();
+			return AMP_Theme_Support::prepare_response( $original_html, $prepare_response_args );
+		};
+
+		$get_server_timing_header_count = function() {
+			return count( array_filter(
+				AMP_Response_Headers::$headers_sent,
+				function( $header ) {
+					return 'Server-Timing' === $header['name'];
+				}
 			) );
 		};
 
 		// Test that first response isn't cached.
-		$first_response = $call_response();
-		$this->assertGreaterThan( 0, count( array_filter(
-			AMP_Response_Headers::$headers_sent,
-			function( $header ) {
-				return 'Server-Timing' === $header['name'];
-			}
-		) ) );
+		$first_response = $call_prepare_response();
+		$this->assertGreaterThan( 0, $get_server_timing_header_count() );
+		$this->assertContains( '<html amp>', $first_response ); // Note: AMP because sanitized validation errors.
 
 		// Test that response cache is return upon second call.
-		AMP_Response_Headers::$headers_sent = array();
-		$this->assertEquals( $first_response, $call_response() );
-		$this->assertSame( 0, count( array_filter(
-			AMP_Response_Headers::$headers_sent,
-			function( $header ) {
-				return 'Server-Timing' === $header['name'];
-			}
-		) ) );
+		$this->assertEquals( $first_response, $call_prepare_response() );
+		$this->assertSame( 0, $get_server_timing_header_count() );
 
 		// Test new cache upon argument change.
-		AMP_Response_Headers::$headers_sent = array();
-		AMP_Theme_Support::prepare_response( $original_html, array(
-			'enable_response_caching' => true,
-			'test_reset_by_arg'       => true,
-		) );
-		$this->assertGreaterThan( 0, count( array_filter(
-			AMP_Response_Headers::$headers_sent,
-			function( $header ) {
-				return 'Server-Timing' === $header['name'];
-			}
-		) ) );
+		$prepare_response_args['test_reset_by_arg'] = true;
+		$call_prepare_response();
+		$this->assertGreaterThan( 0, $get_server_timing_header_count() );
+
+		// Test response is cached.
+		$call_prepare_response();
+		$this->assertSame( 0, $get_server_timing_header_count() );
+
+		// Test that response is no longer cached due to a change whether validation errors are sanitized.
+		remove_filter( 'amp_validation_error_sanitized', '__return_true' );
+		add_filter( 'amp_validation_error_sanitized', '__return_false' );
+		$prepared_html = $call_prepare_response();
+		$this->assertGreaterThan( 0, $get_server_timing_header_count() );
+		$this->assertContains( '<html>', $prepared_html ); // Note: no AMP because unsanitized validation error.
+
+		// And test response is cached.
+		$call_prepare_response();
+		$this->assertSame( 0, $get_server_timing_header_count() );
 	}
 
 	/**