diff --git a/django/contrib/auth/models.py b/django/contrib/auth/models.py
index eb39868..fb5ad10 100644
--- a/django/contrib/auth/models.py
+++ b/django/contrib/auth/models.py
@@ -408,8 +408,8 @@ class AnonymousUser(object):
     is_staff = False
     is_active = False
     is_superuser = False
-    _groups = EmptyManager()
-    _user_permissions = EmptyManager()
+    _groups = EmptyManager(model=User)
+    _user_permissions = EmptyManager(model=User)
 
     def __init__(self):
         pass
diff --git a/django/db/models/manager.py b/django/db/models/manager.py
index e1bbf6e..28a320a 100644
--- a/django/db/models/manager.py
+++ b/django/db/models/manager.py
@@ -1,6 +1,6 @@
 import copy
 from django.db import router
-from django.db.models.query import QuerySet, EmptyQuerySet, insert_query, RawQuerySet
+from django.db.models.query import QuerySet, insert_query, RawQuerySet
 from django.db.models import signals
 from django.db.models.fields import FieldDoesNotExist
 
@@ -46,10 +46,10 @@ class Manager(object):
     # Tracks each time a Manager instance is created. Used to retain order.
     creation_counter = 0
 
-    def __init__(self):
+    def __init__(self, model=None):
         super(Manager, self).__init__()
         self._set_creation_counter()
-        self.model = None
+        self.model = model
         self._inherited = False
         self._db = None
 
@@ -101,7 +101,7 @@ class Manager(object):
     #######################
 
     def get_empty_query_set(self):
-        return EmptyQuerySet(self.model, using=self._db)
+        return QuerySet(self.model, using=self.db).none()
 
     def get_query_set(self):
         """Returns a new QuerySet object.  Subclasses can override this method
diff --git a/django/db/models/query.py b/django/db/models/query.py
index 41c24c7..0d91ce9 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -31,7 +31,6 @@ class QuerySet(object):
     """
     def __init__(self, model=None, query=None, using=None):
         self.model = model
-        # EmptyQuerySet instantiates QuerySet with model as None
         self._db = using
         self.query = query or sql.Query(self.model)
         self._result_cache = None
@@ -210,8 +209,6 @@ class QuerySet(object):
 
     def __and__(self, other):
         self._merge_sanity_check(other)
-        if isinstance(other, EmptyQuerySet):
-            return other._clone()
         combined = self._clone()
         combined.query.combine(other.query, sql.AND)
         return combined
@@ -219,8 +216,6 @@ class QuerySet(object):
     def __or__(self, other):
         self._merge_sanity_check(other)
         combined = self._clone()
-        if isinstance(other, EmptyQuerySet):
-            return combined
         combined.query.combine(other.query, sql.OR)
         return combined
 
@@ -600,7 +595,9 @@ class QuerySet(object):
         """
         Returns an empty QuerySet.
         """
-        return self._clone(klass=EmptyQuerySet)
+        c = self._clone()
+        c.query.set_empty()
+        return c
 
     ##################################################################
     # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
@@ -1116,127 +1113,6 @@ class DateQuerySet(QuerySet):
             c._setup_query()
         return c
 
-
-class EmptyQuerySet(QuerySet):
-    def __init__(self, model=None, query=None, using=None):
-        super(EmptyQuerySet, self).__init__(model, query, using)
-        self._result_cache = []
-
-    def __and__(self, other):
-        return self._clone()
-
-    def __or__(self, other):
-        return other._clone()
-
-    def count(self):
-        return 0
-
-    def delete(self):
-        pass
-
-    def _clone(self, klass=None, setup=False, **kwargs):
-        c = super(EmptyQuerySet, self)._clone(klass, setup=setup, **kwargs)
-        c._result_cache = []
-        return c
-
-    def iterator(self):
-        # This slightly odd construction is because we need an empty generator
-        # (it raises StopIteration immediately).
-        yield iter([]).next()
-
-    def all(self):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def filter(self, *args, **kwargs):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def exclude(self, *args, **kwargs):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def complex_filter(self, filter_obj):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def select_related(self, *fields, **kwargs):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def annotate(self, *args, **kwargs):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def order_by(self, *field_names):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def distinct(self, fields=None):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def extra(self, select=None, where=None, params=None, tables=None,
-              order_by=None, select_params=None):
-        """
-        Always returns EmptyQuerySet.
-        """
-        assert self.query.can_filter(), \
-                "Cannot change a query once a slice has been taken"
-        return self
-
-    def reverse(self):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def defer(self, *fields):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def only(self, *fields):
-        """
-        Always returns EmptyQuerySet.
-        """
-        return self
-
-    def update(self, **kwargs):
-        """
-        Don't update anything.
-        """
-        return 0
-
-    def aggregate(self, *args, **kwargs):
-        """
-        Return a dict mapping the aggregate names to None
-        """
-        for arg in args:
-            kwargs[arg.default_alias] = arg
-        return dict([(key, None) for key in kwargs])
-
-    # EmptyQuerySet is always an empty result in where-clauses (and similar
-    # situations).
-    value_annotation = False
-
 def get_klass_info(klass, max_depth=0, cur_depth=0, requested=None,
                    only_load=None, local_only=False):
     """
diff --git a/django/db/models/sql/compiler.py b/django/db/models/sql/compiler.py
index 72948f9..6808b34 100644
--- a/django/db/models/sql/compiler.py
+++ b/django/db/models/sql/compiler.py
@@ -60,7 +60,6 @@ class SQLCompiler(object):
         """
         if with_limits and self.query.low_mark == self.query.high_mark:
             return '', ()
-
         self.pre_sql_setup()
         # After executing the query, we must get rid of any joins the query
         # setup created. So, take note of alias counts before the query ran.
diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index a78df34..825647d 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -22,7 +22,7 @@ from django.db.models.sql.constants import *
 from django.db.models.sql.datastructures import EmptyResultSet, Empty, MultiJoin
 from django.db.models.sql.expressions import SQLEvaluator
 from django.db.models.sql.where import (WhereNode, Constraint, EverythingNode,
-    ExtraWhere, AND, OR)
+    ExtraWhere, AND, OR, NothingNode)
 from django.core.exceptions import FieldError
 
 __all__ = ['Query', 'RawQuery']
@@ -426,6 +426,13 @@ class Query(object):
 
         return number
 
+    def set_empty(self):
+        """
+        Turn this queryset into one which will return nothing when evaluated.
+        """
+        self.where = self.where_class()
+        self.where.add(NothingNode(), AND)
+
     def has_results(self, using):
         q = self.clone()
         q.add_extra({'a': 1}, None, None, None, None, None)
diff --git a/django/db/models/sql/where.py b/django/db/models/sql/where.py
index 1455ba6..36cf82d 100644
--- a/django/db/models/sql/where.py
+++ b/django/db/models/sql/where.py
@@ -36,6 +36,9 @@ class WhereNode(tree.Node):
     """
     default = AND
 
+    def __init__(self, *args, **kwargs):
+        super(WhereNode, self).__init__(*args, **kwargs)
+
     def add(self, data, connector):
         """
         Add a node to the where-tree. If the data is a list or tuple, it is
@@ -252,6 +255,7 @@ class WhereNode(tree.Node):
                 if hasattr(child[3], 'relabel_aliases'):
                     child[3].relabel_aliases(change_map)
 
+
 class EverythingNode(object):
     """
     A node that matches everything.
diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt
index 103cae1..886cbf6 100644
--- a/docs/ref/models/querysets.txt
+++ b/docs/ref/models/querysets.txt
@@ -601,8 +601,8 @@ none
 
 .. method:: none()
 
-Returns an ``EmptyQuerySet`` — a ``QuerySet`` subclass that always evaluates to
-an empty list. This can be used in cases where you know that you should return
+Returns a ``QuerySet`` that always evaluates to an empty list. No query should
+be executed. This can be used in cases where you know that you should return
 an empty result set and your caller is expecting a ``QuerySet`` object (instead
 of returning an empty list, for example.)
 
diff --git a/tests/modeltests/get_object_or_404/tests.py b/tests/modeltests/get_object_or_404/tests.py
index 280720f..992a2f3 100644
--- a/tests/modeltests/get_object_or_404/tests.py
+++ b/tests/modeltests/get_object_or_404/tests.py
@@ -53,7 +53,7 @@ class GetObjectOr404Tests(TestCase):
             get_object_or_404, Author.objects.all()
         )
 
-        # Using an EmptyQuerySet raises a Http404 error.
+        # Using a empty queryset raises a Http404 error.
         self.assertRaises(Http404,
             get_object_or_404, Article.objects.none(), title__contains="Run"
         )
diff --git a/tests/modeltests/lookup/tests.py b/tests/modeltests/lookup/tests.py
index 3571e21..5333402 100644
--- a/tests/modeltests/lookup/tests.py
+++ b/tests/modeltests/lookup/tests.py
@@ -436,7 +436,7 @@ class LookupTests(TestCase):
             ])
 
     def test_none(self):
-       # none() returns an EmptyQuerySet that behaves like any other QuerySet object
+       # none() returns an empty queryset that behaves like any other QuerySet object
         self.assertQuerysetEqual(Article.objects.none(), [])
         self.assertQuerysetEqual(
             Article.objects.none().filter(headline__startswith='Article'), [])
diff --git a/tests/regressiontests/queries/tests.py b/tests/regressiontests/queries/tests.py
index ded3e8f..a706c82 100644
--- a/tests/regressiontests/queries/tests.py
+++ b/tests/regressiontests/queries/tests.py
@@ -8,7 +8,7 @@ from django.conf import settings
 from django.core.exceptions import FieldError
 from django.db import DatabaseError, connection, connections, DEFAULT_DB_ALIAS
 from django.db.models import Count
-from django.db.models.query import Q, ITER_CHUNK_SIZE, EmptyQuerySet
+from django.db.models.query import Q, ITER_CHUNK_SIZE
 from django.test import TestCase, skipUnlessDBFeature
 from django.utils import unittest
 from django.utils.datastructures import SortedDict
@@ -655,31 +655,6 @@ class Queries1Tests(BaseQuerysetTest):
             ['<Item: one>', '<Item: two>']
         )
 
-    def test_ticket7235(self):
-        # An EmptyQuerySet should not raise exceptions if it is filtered.
-        q = EmptyQuerySet()
-        self.assertQuerysetEqual(q.all(), [])
-        self.assertQuerysetEqual(q.filter(x=10), [])
-        self.assertQuerysetEqual(q.exclude(y=3), [])
-        self.assertQuerysetEqual(q.complex_filter({'pk': 1}), [])
-        self.assertQuerysetEqual(q.select_related('spam', 'eggs'), [])
-        self.assertQuerysetEqual(q.annotate(Count('eggs')), [])
-        self.assertQuerysetEqual(q.order_by('-pub_date', 'headline'), [])
-        self.assertQuerysetEqual(q.distinct(), [])
-        self.assertQuerysetEqual(
-            q.extra(select={'is_recent': "pub_date > '2006-01-01'"}),
-            []
-        )
-        q.query.low_mark = 1
-        self.assertRaisesMessage(
-            AssertionError,
-            'Cannot change a query once a slice has been taken',
-            q.extra, select={'is_recent': "pub_date > '2006-01-01'"}
-        )
-        self.assertQuerysetEqual(q.reverse(), [])
-        self.assertQuerysetEqual(q.defer('spam', 'eggs'), [])
-        self.assertQuerysetEqual(q.only('spam', 'eggs'), [])
-
     def test_ticket7791(self):
         # There were "issues" when ordering and distinct-ing on fields related
         # via ForeignKeys.
@@ -1613,7 +1588,7 @@ class CloneTests(TestCase):
 
 class EmptyQuerySetTests(TestCase):
     def test_emptyqueryset_values(self):
-        # #14366 -- Calling .values() on an EmptyQuerySet and then cloning that
+        # #14366 -- Calling .values() on an empty queryset and then cloning that
         # should not cause an error"
         self.assertQuerysetEqual(
             Number.objects.none().values('num').order_by('num'), []
