diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
index a2a1757..c80dddc 100644
--- a/django/db/backends/__init__.py
+++ b/django/db/backends/__init__.py
@@ -1166,7 +1166,7 @@ class BaseDatabaseOperations(object):
         """
         first = datetime.datetime(value, 1, 1)
         second = datetime.datetime(value, 12, 31, 23, 59, 59, 999999)
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             tz = timezone.get_current_timezone()
             first = timezone.make_aware(first, tz)
             second = timezone.make_aware(second, tz)
diff --git a/django/db/backends/mysql/base.py b/django/db/backends/mysql/base.py
index b38d00c..1dc0b66 100644
--- a/django/db/backends/mysql/base.py
+++ b/django/db/backends/mysql/base.py
@@ -62,6 +62,7 @@ parse_datetime = conversions[FIELD_TYPE.DATETIME]
 def parse_datetime_with_timezone_support(value):
     dt = parse_datetime(value)
     # Confirm that dt is naive before overwriting its tzinfo.
+    # XXX must inject use_tz instead of using the global setting
     if dt is not None and settings.USE_TZ and timezone.is_naive(dt):
         dt = dt.replace(tzinfo=timezone.utc)
     return dt
@@ -69,6 +70,7 @@ def parse_datetime_with_timezone_support(value):
 
 def adapt_datetime_with_timezone_support(value, conv):
     # Equivalent to DateTimeField.get_db_prep_value. Used only by raw SQL.
+    # XXX must inject use_tz instead of using the global setting
     if settings.USE_TZ:
         if timezone.is_naive(value):
             warnings.warn("MySQL received a naive datetime (%s)"
@@ -238,7 +240,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         return sql
 
     def datetime_extract_sql(self, lookup_type, field_name, tzname):
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             field_name = "CONVERT_TZ(%s, 'UTC', %%s)" % field_name
             params = [tzname]
         else:
@@ -253,7 +255,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         return sql, params
 
     def datetime_trunc_sql(self, lookup_type, field_name, tzname):
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             field_name = "CONVERT_TZ(%s, 'UTC', %%s)" % field_name
             params = [tzname]
         else:
@@ -355,7 +357,7 @@ class DatabaseOperations(BaseDatabaseOperations):
 
         # MySQL doesn't support tz-aware datetimes
         if timezone.is_aware(value):
-            if settings.USE_TZ:
+            if self.connection.settings_dict['USE_TZ']:
                 value = value.astimezone(timezone.utc).replace(tzinfo=None)
             else:
                 raise ValueError("MySQL backend does not support timezone-aware datetimes when USE_TZ is False.")
diff --git a/django/db/backends/oracle/base.py b/django/db/backends/oracle/base.py
index 6a6a877..bc40175 100644
--- a/django/db/backends/oracle/base.py
+++ b/django/db/backends/oracle/base.py
@@ -197,7 +197,7 @@ WHEN (new.%(col_name)s IS NULL)
         return "CAST(%s AS TIMESTAMP)" % result
 
     def datetime_extract_sql(self, lookup_type, field_name, tzname):
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             field_name = self._convert_field_to_tz(field_name, tzname)
         if lookup_type == 'week_day':
             # TO_CHAR(field, 'D') returns an integer from 1-7, where 1=Sunday.
@@ -208,7 +208,7 @@ WHEN (new.%(col_name)s IS NULL)
         return sql, []
 
     def datetime_trunc_sql(self, lookup_type, field_name, tzname):
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             field_name = self._convert_field_to_tz(field_name, tzname)
         # http://docs.oracle.com/cd/B19306_01/server.102/b14200/functions230.htm#i1002084
         if lookup_type in ('year', 'month'):
@@ -437,7 +437,7 @@ WHEN (new.%(col_name)s IS NULL)
 
         # Oracle doesn't support tz-aware datetimes
         if timezone.is_aware(value):
-            if settings.USE_TZ:
+            if self.connection.settings_dict['USE_TZ']:
                 value = value.astimezone(timezone.utc).replace(tzinfo=None)
             else:
                 raise ValueError("Oracle backend does not support timezone-aware datetimes when USE_TZ is False.")
@@ -470,7 +470,7 @@ WHEN (new.%(col_name)s IS NULL)
         # off of datetime objects, leaving almost an entire second out of
         # the year under the default implementation.
         bounds = super(DatabaseOperations, self).year_lookup_bounds_for_datetime_field(value)
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             bounds = [b.astimezone(timezone.utc).replace(tzinfo=None) for b in bounds]
         return [b.isoformat(b' ') for b in bounds]
 
@@ -589,10 +589,10 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         # once when we create a new connection. We also set the Territory
         # to 'AMERICA' which forces Sunday to evaluate to a '1' in
         # TO_CHAR().
+        tz = " TIME_ZONE = 'UTC'" if self.settings_dict['USE_TZ'] else ""
         cursor.execute(
             "ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'"
-            " NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'"
-            + (" TIME_ZONE = 'UTC'" if settings.USE_TZ else ''))
+            " NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'" + tz)
         cursor.close()
         if 'operators' not in self.__dict__:
             # Ticket #14149: Check whether our LIKE implementation will
@@ -702,6 +702,7 @@ class OracleParam(object):
     def __init__(self, param, cursor, strings_only=False):
         # With raw SQL queries, datetimes can reach this function
         # without being converted by DateTimeField.get_db_prep_value.
+        # XXX must inject use_tz instead of using the global setting
         if settings.USE_TZ and isinstance(param, datetime.datetime):
             if timezone.is_naive(param):
                 warnings.warn("Oracle received a naive datetime (%s)"
@@ -956,6 +957,7 @@ def _rowfactory(row, cursor):
         # of "dates" queries, which are returned as DATETIME.
         elif desc[1] in (Database.TIMESTAMP, Database.DATETIME):
             # Confirm that dt is naive before overwriting its tzinfo.
+            # XXX must inject use_tz instead of using the global setting
             if settings.USE_TZ and value is not None and timezone.is_naive(value):
                 value = value.replace(tzinfo=timezone.utc)
         elif desc[1] in (Database.STRING, Database.FIXED_CHAR,
diff --git a/django/db/backends/postgresql_psycopg2/base.py b/django/db/backends/postgresql_psycopg2/base.py
index cb23c33..b142b89 100644
--- a/django/db/backends/postgresql_psycopg2/base.py
+++ b/django/db/backends/postgresql_psycopg2/base.py
@@ -131,7 +131,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     def init_connection_state(self):
         settings_dict = self.settings_dict
         self.connection.set_client_encoding('UTF8')
-        tz = 'UTC' if settings.USE_TZ else settings_dict.get('TIME_ZONE')
+        tz = 'UTC' if settings_dict['USE_TZ'] else settings_dict['TIME_ZONE']
         if tz:
             try:
                 get_parameter_status = self.connection.get_parameter_status
@@ -151,7 +151,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
 
     def create_cursor(self):
         cursor = self.connection.cursor()
-        cursor.tzinfo_factory = utc_tzinfo_factory if settings.USE_TZ else None
+        cursor.tzinfo_factory = utc_tzinfo_factory if self.settings_dict['USE_TZ'] else None
         return cursor
 
     def close(self):
diff --git a/django/db/backends/postgresql_psycopg2/operations.py b/django/db/backends/postgresql_psycopg2/operations.py
index b949686..ae08177 100644
--- a/django/db/backends/postgresql_psycopg2/operations.py
+++ b/django/db/backends/postgresql_psycopg2/operations.py
@@ -38,7 +38,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         return "DATE_TRUNC('%s', %s)" % (lookup_type, field_name)
 
     def datetime_extract_sql(self, lookup_type, field_name, tzname):
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             field_name = "%s AT TIME ZONE %%s" % field_name
             params = [tzname]
         else:
@@ -52,7 +52,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         return sql, params
 
     def datetime_trunc_sql(self, lookup_type, field_name, tzname):
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             field_name = "%s AT TIME ZONE %%s" % field_name
             params = [tzname]
         else:
diff --git a/django/db/backends/sqlite3/base.py b/django/db/backends/sqlite3/base.py
index 6c97288..78cdefe 100644
--- a/django/db/backends/sqlite3/base.py
+++ b/django/db/backends/sqlite3/base.py
@@ -49,6 +49,7 @@ IntegrityError = Database.IntegrityError
 def parse_datetime_with_timezone_support(value):
     dt = parse_datetime(value)
     # Confirm that dt is naive before overwriting its tzinfo.
+    # XXX must inject use_tz instead of using the global setting
     if dt is not None and settings.USE_TZ and timezone.is_naive(dt):
         dt = dt.replace(tzinfo=timezone.utc)
     return dt
@@ -56,6 +57,7 @@ def parse_datetime_with_timezone_support(value):
 
 def adapt_datetime_with_timezone_support(value):
     # Equivalent to DateTimeField.get_db_prep_value. Used only by raw SQL.
+    # XXX must inject use_tz instead of using the global setting
     if settings.USE_TZ:
         if timezone.is_naive(value):
             warnings.warn("SQLite received a naive datetime (%s)"
@@ -186,7 +188,7 @@ class DatabaseOperations(BaseDatabaseOperations):
 
     def datetime_extract_sql(self, lookup_type, field_name, tzname):
         # Same comment as in date_extract_sql.
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             if pytz is None:
                 from django.core.exceptions import ImproperlyConfigured
                 raise ImproperlyConfigured("This query requires pytz, "
@@ -196,7 +198,7 @@ class DatabaseOperations(BaseDatabaseOperations):
 
     def datetime_trunc_sql(self, lookup_type, field_name, tzname):
         # Same comment as in date_trunc_sql.
-        if settings.USE_TZ:
+        if self.connection.settings_dict['USE_TZ']:
             if pytz is None:
                 from django.core.exceptions import ImproperlyConfigured
                 raise ImproperlyConfigured("This query requires pytz, "
@@ -256,7 +258,7 @@ class DatabaseOperations(BaseDatabaseOperations):
 
         # SQLite doesn't support tz-aware datetimes
         if timezone.is_aware(value):
-            if settings.USE_TZ:
+            if self.connection.settings_dict['USE_TZ']:
                 value = value.astimezone(timezone.utc).replace(tzinfo=None)
             else:
                 raise ValueError("SQLite backend does not support timezone-aware datetimes when USE_TZ is False.")
diff --git a/django/db/backends/utils.py b/django/db/backends/utils.py
index 8bed641..b4b2f28 100644
--- a/django/db/backends/utils.py
+++ b/django/db/backends/utils.py
@@ -151,6 +151,7 @@ def typecast_timestamp(s):  # does NOT store time zone information
         seconds, microseconds = seconds.split('.')
     else:
         microseconds = '0'
+    # XXX must inject use_tz instead of using the global setting
     tzinfo = utc if settings.USE_TZ else None
     return datetime.datetime(int(dates[0]), int(dates[1]), int(dates[2]),
         int(times[0]), int(times[1]), int(seconds),
diff --git a/django/db/models/query.py b/django/db/models/query.py
index 58180e1..f2759b2 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -650,6 +650,7 @@ class QuerySet(object):
                 "'kind' must be one of 'year', 'month', 'day', 'hour', 'minute' or 'second'."
         assert order in ('ASC', 'DESC'), \
                 "'order' must be either 'ASC' or 'DESC'."
+        # XXX must inject use_tz instead of using the global setting
         if settings.USE_TZ:
             if tzinfo is None:
                 tzinfo = timezone.get_current_timezone()
diff --git a/django/db/models/sql/compiler.py b/django/db/models/sql/compiler.py
index 98b9539..062eea3 100644
--- a/django/db/models/sql/compiler.py
+++ b/django/db/models/sql/compiler.py
@@ -1080,6 +1080,7 @@ class SQLDateTimeCompiler(SQLCompiler):
                     datetime = typecast_timestamp(str(datetime))
                 # Datetimes are artifically returned in UTC on databases that
                 # don't support time zone. Restore the zone used in the query.
+                # XXX must inject use_tz instead of using the global setting
                 if settings.USE_TZ:
                     if datetime is None:
                         raise ValueError("Database returned an invalid value "
diff --git a/django/db/models/sql/subqueries.py b/django/db/models/sql/subqueries.py
index e9e292e..13a0ccc 100644
--- a/django/db/models/sql/subqueries.py
+++ b/django/db/models/sql/subqueries.py
@@ -243,6 +243,7 @@ class DateQuery(Query):
     def _check_field(self, field):
         assert isinstance(field, DateField), \
             "%r isn't a DateField." % field.name
+        # XXX must inject use_tz instead of using the global setting
         if settings.USE_TZ:
             assert not isinstance(field, DateTimeField), \
                 "%r is a DateTimeField, not a DateField." % field.name
diff --git a/django/db/models/sql/where.py b/django/db/models/sql/where.py
index 44a4ce9..0d86acb 100644
--- a/django/db/models/sql/where.py
+++ b/django/db/models/sql/where.py
@@ -244,6 +244,7 @@ class WhereNode(tree.Node):
             return ('%s BETWEEN %%s and %%s' % field_sql, params)
         elif is_datetime_field and lookup_type in ('month', 'day', 'week_day',
                                                    'hour', 'minute', 'second'):
+            # XXX must inject use_tz instead of using the global setting
             tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
             sql, tz_params = connection.ops.datetime_extract_sql(lookup_type, field_sql, tzname)
             return ('%s = %%s' % sql, tz_params + params)
diff --git a/django/db/utils.py b/django/db/utils.py
index 43abaf9..91f08d4 100644
--- a/django/db/utils.py
+++ b/django/db/utils.py
@@ -177,7 +177,8 @@ class ConnectionHandler(object):
             conn['ENGINE'] = 'django.db.backends.dummy'
         conn.setdefault('CONN_MAX_AGE', 0)
         conn.setdefault('OPTIONS', {})
-        conn.setdefault('TIME_ZONE', 'UTC' if settings.USE_TZ else settings.TIME_ZONE)
+        conn.setdefault('USE_TZ', settings.USE_TZ)
+        conn.setdefault('TIME_ZONE', settings.TIME_ZONE)
         for setting in ['NAME', 'USER', 'PASSWORD', 'HOST', 'PORT']:
             conn.setdefault(setting, '')
         for setting in ['TEST_CHARSET', 'TEST_COLLATION', 'TEST_NAME', 'TEST_MIRROR']:
diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
index d9cb07e..e55e165 100644
--- a/docs/ref/settings.txt
+++ b/docs/ref/settings.txt
@@ -570,6 +570,19 @@ Default: ``''`` (Empty string)
 The port to use when connecting to the database. An empty string means the
 default port. Not used with SQLite.
 
+.. setting:: DATABASES-TIMEZONE
+
+TIME_ZONE
+~~~~~~~~~
+
+Default: global :setting:`TIME_ZONE` setting
+
+Time zone for this database connection. This is for advanced use only.
+
+This parameter isn't used when :setting:`DATABASES-USE_TZ` is ``False`` and
+has no effect on databases that do not support setting the connection's time
+zone (SQLite and MySQL).
+
 .. setting:: USER
 
 USER
@@ -579,6 +592,20 @@ Default: ``''`` (Empty string)
 
 The username to use when connecting to the database. Not used with SQLite.
 
+.. setting:: DATABASES-USE_TZ
+
+USE_TZ
+~~~~~~
+
+Default: global :setting:`USE_TZ` setting
+
+Controls if this database connection returns aware datetimes. This is for
+advanced use only.
+
+If you override this value, you must ensure that your application code
+performs appropriate conversions between naive and aware datetimes when
+getting them from or passing them to the ORM.
+
 .. setting:: TEST_CHARSET
 
 TEST_CHARSET
