diff --git a/src/context/context.rs b/src/context/context.rs
index ba2befb5..01c3d461 100644
--- a/src/context/context.rs
+++ b/src/context/context.rs
@@ -12,7 +12,6 @@ use crate::error::CustomError;
 use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::OrgSource;
-use crate::types::Keyword;
 
 #[derive(Debug)]
 pub(crate) enum ContextElement<'r, 's> {
@@ -25,22 +24,11 @@ pub(crate) enum ContextElement<'r, 's> {
     /// Indicates if elements should consume the whitespace after them.
     ConsumeTrailingWhitespace(bool),
 
-    /// Indicate that we are parsing a paragraph that already has affiliated keywords.
-    ///
-    /// The value stored is the start of the element after the affiliated keywords. In this way, we can ensure that we do not exit an element immediately after the affiliated keyword had been consumed.
-    HasAffiliatedKeyword(HasAffiliatedKeywordInner<'r, 's>),
-
     /// This is just here to use the 's lifetime until I'm sure we can eliminate it from ContextElement.
     #[allow(dead_code)]
     Placeholder(PhantomData<&'s str>),
 }
 
-#[derive(Debug, Clone)]
-pub(crate) struct HasAffiliatedKeywordInner<'r, 's> {
-    pub(crate) start_after_affiliated_keywords: OrgSource<'s>,
-    pub(crate) keywords: &'r Vec<Keyword<'s>>,
-}
-
 pub(crate) struct ExitMatcherNode<'r> {
     // TODO: Should this be "&'r DynContextMatcher<'c>" ?
     pub(crate) exit_matcher: &'r DynContextMatcher<'r>,
diff --git a/src/context/mod.rs b/src/context/mod.rs
index 40b7e279..20dfed2e 100644
--- a/src/context/mod.rs
+++ b/src/context/mod.rs
@@ -22,7 +22,6 @@ type DynMatcher<'c> = dyn Matcher + 'c;
 pub(crate) use context::Context;
 pub(crate) use context::ContextElement;
 pub(crate) use context::ExitMatcherNode;
-pub(crate) use context::HasAffiliatedKeywordInner;
 pub(crate) use exiting::ExitClass;
 pub use file_access_interface::FileAccessInterface;
 pub use file_access_interface::LocalFileAccessInterface;
diff --git a/src/parser/paragraph.rs b/src/parser/paragraph.rs
index 23dff72c..90331eb3 100644
--- a/src/parser/paragraph.rs
+++ b/src/parser/paragraph.rs
@@ -13,16 +13,12 @@ use super::keyword::affiliated_keyword;
 use super::org_source::OrgSource;
 use super::util::blank_line;
 use super::util::get_consumed;
-use super::util::get_has_affiliated_keyword;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::ExitClass;
 use crate::context::ExitMatcherNode;
-use crate::context::HasAffiliatedKeywordInner;
 use crate::context::RefContext;
-use crate::error::CustomError;
-use crate::error::MyError;
 use crate::error::Res;
 use crate::parser::object_parser::standard_set_object;
 use crate::parser::util::exit_matcher_parser;
@@ -38,18 +34,11 @@ pub(crate) fn paragraph<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Paragraph<'s>> {
     let (remaining, affiliated_keywords) = many0(affiliated_keyword)(input)?;
-    let contexts = [
-        ContextElement::HasAffiliatedKeyword(HasAffiliatedKeywordInner {
-            start_after_affiliated_keywords: remaining,
-            keywords: &affiliated_keywords,
-        }),
-        ContextElement::ExitMatcherNode(ExitMatcherNode {
-            class: ExitClass::Gamma,
-            exit_matcher: &paragraph_end,
-        }),
-    ];
+    let contexts = [ContextElement::ExitMatcherNode(ExitMatcherNode {
+        class: ExitClass::Gamma,
+        exit_matcher: &paragraph_end,
+    })];
     let parser_context = context.with_additional_node(&contexts[0]);
-    let parser_context = parser_context.with_additional_node(&contexts[1]);
     let standard_set_object_matcher = parser_with_context!(standard_set_object)(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
 
@@ -89,15 +78,6 @@ fn paragraph_end<'b, 'g, 'r, 's>(
     if regular_end.is_ok() {
         return regular_end;
     }
-    match get_has_affiliated_keyword(context) {
-        Some(start_post_affiliated_keywords) if input == start_post_affiliated_keywords => {
-            return Err(nom::Err::Error(CustomError::MyError(MyError(
-                "No exit due to affiliated keywords.",
-            ))));
-        }
-        _ => {}
-    }
-    // Check to see if input is the start of a HasAffiliatedKeyword
     alt((
         recognize(parser_with_context!(detect_element(false))(context)),
         eof,
diff --git a/src/parser/util.rs b/src/parser/util.rs
index 05a292e2..4ee8a27c 100644
--- a/src/parser/util.rs
+++ b/src/parser/util.rs
@@ -271,24 +271,6 @@ pub(crate) fn indentation_level<'b, 'g, 'r, 's>(
     Ok((remaining, (indentation_level, leading_whitespace)))
 }
 
-pub(crate) fn get_has_affiliated_keyword<'b, 'g, 'r, 's>(
-    context: RefContext<'b, 'g, 'r, 's>,
-) -> Option<OrgSource<'s>> {
-    for context in context.iter() {
-        match context {
-            ContextElement::HasAffiliatedKeyword(inner) => {
-                if !inner.keywords.is_empty() {
-                    return Some(inner.start_after_affiliated_keywords);
-                } else {
-                    return None;
-                }
-            }
-            _ => {}
-        }
-    }
-    None
-}
-
 /// Reset the input OrgSource as if it was starting a fresh document.
 ///
 /// This is important for making start-of-document, end-of-document, and other context-dependent tests succeed.