diff --git a/CHANGELOG.md b/CHANGELOG.md
index a382df3ba67..32da536d097 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -132,6 +132,7 @@
   * `cortex_querier_blocks_consistency_checks_failed_total`
   * `cortex_querier_storegateway_refetches_per_query`
 * [ENHANCEMENT] Cortex is now built with Go 1.14. #2480 #2753
+* [ENHANCEMENT] Experimental: Querier can now optionally query secondary store. This is specified by using `-querier.second-store-engine` option, with values `chunks` or `tsdb`. Standard configuration options for this store are used. Additionally, this querying can be configured to happen only for queries that need data older than `-querier.use-second-store-before-time`. Default value of zero will always query secondary store. #2747
 * [BUGFIX] Ruler: Ensure temporary rule files with special characters are properly mapped and cleaned up. #2506
 * [BUGFIX] Fixes #2411, Ensure requests are properly routed to the prometheus api embedded in the query if `-server.path-prefix` is set. #2372
 * [BUGFIX] Experimental TSDB: fixed chunk data corruption when querying back series using the experimental blocks storage. #2400
diff --git a/docs/configuration/config-file-reference.md b/docs/configuration/config-file-reference.md
index d0e57e0f8d7..09b1d559c0d 100644
--- a/docs/configuration/config-file-reference.md
+++ b/docs/configuration/config-file-reference.md
@@ -22,6 +22,7 @@ To specify which configuration file to load, pass the `-config.file` flag at the
 * `<string>`: a regular string
 * `<url>`: an URL
 * `<prefix>`: a CLI flag prefix based on the context (look at the parent configuration block to see which CLI flags prefix should be used)
+* `<time>`: a timestamp, with available formats: `2006-01-20` (midnight, local timezone), `2006-01-20T15:04` (local timezone), and RFC 3339 formats: `2006-01-20T15:04:05Z` (UTC) or `2006-01-20T15:04:05+07:00` (explicit timezone)
 
 ### Use environment variables in the configuration
 
@@ -667,6 +668,15 @@ store_gateway_client:
   # TLS CA path for the client
   # CLI flag: -experimental.querier.store-gateway-client.tls-ca-path
   [tls_ca_path: <string> | default = ""]
+
+# Second store engine to use for querying. Empty = disabled.
+# CLI flag: -querier.second-store-engine
+[second_store_engine: <string> | default = ""]
+
+# If specified, second store is only used for queries before this timestamp.
+# Default value 0 means secondary store is always queried.
+# CLI flag: -querier.use-second-store-before-time
+[use_second_store_before_time: <time> | default = 0]
 ```
 
 ### `query_frontend_config`
diff --git a/docs/configuration/config-file-reference.template b/docs/configuration/config-file-reference.template
index b5c2b3d7b29..7eafe5e42da 100644
--- a/docs/configuration/config-file-reference.template
+++ b/docs/configuration/config-file-reference.template
@@ -22,6 +22,7 @@ To specify which configuration file to load, pass the `-config.file` flag at the
 * `<string>`: a regular string
 * `<url>`: an URL
 * `<prefix>`: a CLI flag prefix based on the context (look at the parent configuration block to see which CLI flags prefix should be used)
+* `<time>`: a timestamp, with available formats: `2006-01-20` (midnight, local timezone), `2006-01-20T15:04` (local timezone), and RFC 3339 formats: `2006-01-20T15:04:05Z` (UTC) or `2006-01-20T15:04:05+07:00` (explicit timezone)
 
 ### Use environment variables in the configuration
 
diff --git a/docs/configuration/v1-guarantees.md b/docs/configuration/v1-guarantees.md
index 341531f7765..16acc4399d7 100644
--- a/docs/configuration/v1-guarantees.md
+++ b/docs/configuration/v1-guarantees.md
@@ -45,3 +45,4 @@ Currently experimental features are:
 - In-memory (FIFO) and Redis cache.
 - Openstack Swift storage.
 - gRPC Store.
+- Querier support for querying chunks and blocks store at the same time.
diff --git a/pkg/chunk/chunk_store.go b/pkg/chunk/chunk_store.go
index 45721b04608..41eef9c41be 100644
--- a/pkg/chunk/chunk_store.go
+++ b/pkg/chunk/chunk_store.go
@@ -446,7 +446,7 @@ func (c *store) lookupChunksByMetricName(ctx context.Context, userID string, fro
 }
 
 func (c *baseStore) lookupIdsByMetricNameMatcher(ctx context.Context, from, through model.Time, userID, metricName string, matcher *labels.Matcher, filter func([]IndexQuery) []IndexQuery) ([]string, error) {
-	log, ctx := spanlogger.New(ctx, "Store.lookupIdsByMetricNameMatcher", "metricName", metricName, "matcher", matcher)
+	log, ctx := spanlogger.New(ctx, "Store.lookupIdsByMetricNameMatcher", "metricName", metricName, "matcher", formatMatcher(matcher))
 	defer log.Span.Finish()
 
 	var err error
@@ -474,11 +474,11 @@ func (c *baseStore) lookupIdsByMetricNameMatcher(ctx context.Context, from, thro
 	if err != nil {
 		return nil, err
 	}
-	level.Debug(log).Log("matcher", matcher, "queries", len(queries))
+	level.Debug(log).Log("matcher", formatMatcher(matcher), "queries", len(queries))
 
 	if filter != nil {
 		queries = filter(queries)
-		level.Debug(log).Log("matcher", matcher, "filteredQueries", len(queries))
+		level.Debug(log).Log("matcher", formatMatcher(matcher), "filteredQueries", len(queries))
 	}
 
 	entries, err := c.lookupEntriesByQueries(ctx, queries)
@@ -489,17 +489,27 @@ func (c *baseStore) lookupIdsByMetricNameMatcher(ctx context.Context, from, thro
 	} else if err != nil {
 		return nil, err
 	}
-	level.Debug(log).Log("matcher", matcher, "entries", len(entries))
+	level.Debug(log).Log("matcher", formatMatcher(matcher), "entries", len(entries))
 
 	ids, err := c.parseIndexEntries(ctx, entries, matcher)
 	if err != nil {
 		return nil, err
 	}
-	level.Debug(log).Log("matcher", matcher, "ids", len(ids))
+	level.Debug(log).Log("matcher", formatMatcher(matcher), "ids", len(ids))
 
 	return ids, nil
 }
 
+// Using this function avoids logging of nil matcher, which works, but indirectly via panic and recover.
+// That confuses attached debugger, which wants to breakpoint on each panic.
+// Using simple check is also faster.
+func formatMatcher(matcher *labels.Matcher) string {
+	if matcher == nil {
+		return "nil"
+	}
+	return matcher.String()
+}
+
 func (c *baseStore) lookupEntriesByQueries(ctx context.Context, queries []IndexQuery) ([]IndexEntry, error) {
 	log, ctx := spanlogger.New(ctx, "store.lookupEntriesByQueries")
 	defer log.Span.Finish()
diff --git a/pkg/cortex/cortex.go b/pkg/cortex/cortex.go
index 7279a622315..f4d276565d5 100644
--- a/pkg/cortex/cortex.go
+++ b/pkg/cortex/cortex.go
@@ -12,7 +12,6 @@ import (
 	"github.com/go-kit/kit/log/level"
 	"github.com/opentracing/opentracing-go"
 	"github.com/pkg/errors"
-	prom_storage "github.com/prometheus/prometheus/storage"
 	"github.com/thanos-io/thanos/pkg/tracing"
 	"github.com/weaveworks/common/middleware"
 	"github.com/weaveworks/common/server"
@@ -218,9 +217,9 @@ type Cortex struct {
 	StoreGateway *storegateway.StoreGateway
 	MemberlistKV *memberlist.KVInitService
 
-	// Queryable that the querier should use to query the long
+	// Queryables that the querier should use to query the long
 	// term storage. It depends on the storage engine used.
-	StoreQueryable prom_storage.Queryable
+	StoreQueryables []querier.QueryableWithFilter
 }
 
 // New makes a new Cortex.
diff --git a/pkg/cortex/modules.go b/pkg/cortex/modules.go
index 4d2c6db2bdc..35ae0950a2d 100644
--- a/pkg/cortex/modules.go
+++ b/pkg/cortex/modules.go
@@ -3,11 +3,13 @@ package cortex
 import (
 	"fmt"
 	"os"
+	"time"
 
 	"github.com/go-kit/kit/log/level"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prometheus/prometheus/promql"
+	prom_storage "github.com/prometheus/prometheus/storage"
 	httpgrpc_server "github.com/weaveworks/common/httpgrpc/server"
 	"github.com/weaveworks/common/instrument"
 	"github.com/weaveworks/common/server"
@@ -162,7 +164,7 @@ func (t *Cortex) initDistributor() (serv services.Service, err error) {
 }
 
 func (t *Cortex) initQuerier() (serv services.Service, err error) {
-	queryable, engine := querier.New(t.Cfg.Querier, t.Distributor, t.StoreQueryable, t.TombstonesLoader, prometheus.DefaultRegisterer)
+	queryable, engine := querier.New(t.Cfg.Querier, t.Distributor, t.StoreQueryables, t.TombstonesLoader, prometheus.DefaultRegisterer)
 
 	// Prometheus histograms for requests to the querier.
 	querierRequestDuration := promauto.With(prometheus.DefaultRegisterer).NewHistogramVec(prometheus.HistogramOpts{
@@ -194,37 +196,74 @@ func (t *Cortex) initQuerier() (serv services.Service, err error) {
 	return worker, nil
 }
 
-func (t *Cortex) initStoreQueryable() (services.Service, error) {
-	if t.Cfg.Storage.Engine == storage.StorageEngineChunks {
-		t.StoreQueryable = querier.NewChunkStoreQueryable(t.Cfg.Querier, t.Store)
-		return nil, nil
+func (t *Cortex) initStoreQueryables() (services.Service, error) {
+	var servs []services.Service
+
+	//nolint:golint // I prefer this form over removing 'else', because it allows q to have smaller scope.
+	if q, err := initQueryableForEngine(t.Cfg.Storage.Engine, t.Cfg, t.Store, prometheus.DefaultRegisterer); err != nil {
+		return nil, fmt.Errorf("failed to initialize querier for engine '%s': %v", t.Cfg.Storage.Engine, err)
+	} else {
+		t.StoreQueryables = append(t.StoreQueryables, querier.UseAlwaysQueryable(q))
+		if s, ok := q.(services.Service); ok {
+			servs = append(servs, s)
+		}
 	}
 
-	if t.Cfg.Storage.Engine == storage.StorageEngineTSDB && !t.Cfg.TSDB.StoreGatewayEnabled {
-		storeQueryable, err := querier.NewBlockQueryable(t.Cfg.TSDB, t.Cfg.Server.LogLevel, prometheus.DefaultRegisterer)
+	if t.Cfg.Querier.SecondStoreEngine != "" {
+		if t.Cfg.Querier.SecondStoreEngine == t.Cfg.Storage.Engine {
+			return nil, fmt.Errorf("second store engine used by querier '%s' must be different than primary engine '%s'", t.Cfg.Querier.SecondStoreEngine, t.Cfg.Storage.Engine)
+		}
+
+		sq, err := initQueryableForEngine(t.Cfg.Querier.SecondStoreEngine, t.Cfg, t.Store, prometheus.DefaultRegisterer)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("failed to initialize querier for engine '%s': %v", t.Cfg.Querier.SecondStoreEngine, err)
+		}
+
+		t.StoreQueryables = append(t.StoreQueryables, querier.UseBeforeTimestampQueryable(sq, time.Time(t.Cfg.Querier.UseSecondStoreBeforeTime)))
+
+		if s, ok := sq.(services.Service); ok {
+			servs = append(servs, s)
 		}
-		t.StoreQueryable = storeQueryable
-		return storeQueryable, nil
 	}
 
-	if t.Cfg.Storage.Engine == storage.StorageEngineTSDB && t.Cfg.TSDB.StoreGatewayEnabled {
+	// Return service, if any.
+	switch len(servs) {
+	case 0:
+		return nil, nil
+	case 1:
+		return servs[0], nil
+	default:
+		// No need to support this case yet, since chunk store is not a service.
+		// When we get there, we will need a wrapper service, that starts all subservices, and will also monitor them for failures.
+		// Not difficult, but also not necessary right now.
+		return nil, fmt.Errorf("too many services")
+	}
+}
+
+func initQueryableForEngine(engine string, cfg Config, chunkStore chunk.Store, reg prometheus.Registerer) (prom_storage.Queryable, error) {
+	switch engine {
+	case storage.StorageEngineChunks:
+		if chunkStore == nil {
+			return nil, fmt.Errorf("chunk store not initialized")
+		}
+		return querier.NewChunkStoreQueryable(cfg.Querier, chunkStore), nil
+
+	case storage.StorageEngineTSDB:
+		if !cfg.TSDB.StoreGatewayEnabled {
+			return querier.NewBlockQueryable(cfg.TSDB, cfg.Server.LogLevel, reg)
+		}
+
 		// When running in single binary, if the blocks sharding is disabled and no custom
 		// store-gateway address has been configured, we can set it to the running process.
-		if t.Cfg.Target == All && !t.Cfg.StoreGateway.ShardingEnabled && t.Cfg.Querier.StoreGatewayAddresses == "" {
-			t.Cfg.Querier.StoreGatewayAddresses = fmt.Sprintf("127.0.0.1:%d", t.Cfg.Server.GRPCListenPort)
+		if cfg.Target == All && !cfg.StoreGateway.ShardingEnabled && cfg.Querier.StoreGatewayAddresses == "" {
+			cfg.Querier.StoreGatewayAddresses = fmt.Sprintf("127.0.0.1:%d", cfg.Server.GRPCListenPort)
 		}
 
-		storeQueryable, err := querier.NewBlocksStoreQueryableFromConfig(t.Cfg.Querier, t.Cfg.StoreGateway, t.Cfg.TSDB, util.Logger, prometheus.DefaultRegisterer)
-		if err != nil {
-			return nil, err
-		}
-		t.StoreQueryable = storeQueryable
-		return storeQueryable, nil
-	}
+		return querier.NewBlocksStoreQueryableFromConfig(cfg.Querier, cfg.StoreGateway, cfg.TSDB, util.Logger, reg)
 
-	return nil, fmt.Errorf("unknown storage engine '%s'", t.Cfg.Storage.Engine)
+	default:
+		return nil, fmt.Errorf("unknown storage engine '%s'", engine)
+	}
 }
 
 func (t *Cortex) initIngester() (serv services.Service, err error) {
@@ -260,8 +299,8 @@ func (t *Cortex) initFlusher() (serv services.Service, err error) {
 	return t.Flusher, nil
 }
 
-func (t *Cortex) initStore() (serv services.Service, err error) {
-	if t.Cfg.Storage.Engine == storage.StorageEngineTSDB {
+func (t *Cortex) initChunkStore() (serv services.Service, err error) {
+	if t.Cfg.Storage.Engine != storage.StorageEngineChunks && t.Cfg.Querier.SecondStoreEngine != storage.StorageEngineChunks {
 		return nil, nil
 	}
 	err = t.Cfg.Schema.Load()
@@ -411,7 +450,7 @@ func (t *Cortex) initTableManager() (services.Service, error) {
 func (t *Cortex) initRuler() (serv services.Service, err error) {
 	t.Cfg.Ruler.Ring.ListenPort = t.Cfg.Server.GRPCListenPort
 	t.Cfg.Ruler.Ring.KVStore.MemberlistKV = t.MemberlistKV.GetMemberlistKV
-	queryable, engine := querier.New(t.Cfg.Querier, t.Distributor, t.StoreQueryable, t.TombstonesLoader, prometheus.DefaultRegisterer)
+	queryable, engine := querier.New(t.Cfg.Querier, t.Distributor, t.StoreQueryables, t.TombstonesLoader, prometheus.DefaultRegisterer)
 
 	t.Ruler, err = ruler.NewRuler(t.Cfg.Ruler, engine, queryable, t.Distributor, prometheus.DefaultRegisterer, util.Logger)
 	if err != nil {
@@ -521,12 +560,12 @@ func (t *Cortex) setupModuleManager() error {
 	mm.RegisterModule(Ring, t.initRing)
 	mm.RegisterModule(Overrides, t.initOverrides)
 	mm.RegisterModule(Distributor, t.initDistributor)
-	mm.RegisterModule(Store, t.initStore)
+	mm.RegisterModule(Store, t.initChunkStore)
 	mm.RegisterModule(DeleteRequestsStore, t.initDeleteRequestsStore)
 	mm.RegisterModule(Ingester, t.initIngester)
 	mm.RegisterModule(Flusher, t.initFlusher)
 	mm.RegisterModule(Querier, t.initQuerier)
-	mm.RegisterModule(StoreQueryable, t.initStoreQueryable)
+	mm.RegisterModule(StoreQueryable, t.initStoreQueryables)
 	mm.RegisterModule(QueryFrontend, t.initQueryFrontend)
 	mm.RegisterModule(TableManager, t.initTableManager)
 	mm.RegisterModule(Ruler, t.initRuler)
diff --git a/pkg/querier/distributor_queryable.go b/pkg/querier/distributor_queryable.go
index 5aeffb97ab5..675946f0e4c 100644
--- a/pkg/querier/distributor_queryable.go
+++ b/pkg/querier/distributor_queryable.go
@@ -3,6 +3,7 @@ package querier
 import (
 	"context"
 	"sort"
+	"time"
 
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/pkg/labels"
@@ -14,6 +15,7 @@ import (
 	"github.com/cortexproject/cortex/pkg/ingester/client"
 	"github.com/cortexproject/cortex/pkg/prom1/storage/metric"
 	"github.com/cortexproject/cortex/pkg/querier/series"
+	"github.com/cortexproject/cortex/pkg/util"
 	"github.com/cortexproject/cortex/pkg/util/chunkcompat"
 	"github.com/cortexproject/cortex/pkg/util/spanlogger"
 )
@@ -29,17 +31,36 @@ type Distributor interface {
 	MetricsMetadata(ctx context.Context) ([]scrape.MetricMetadata, error)
 }
 
-func newDistributorQueryable(distributor Distributor, streaming bool, iteratorFn chunkIteratorFunc) storage.Queryable {
-	return storage.QueryableFunc(func(ctx context.Context, mint, maxt int64) (storage.Querier, error) {
-		return &distributorQuerier{
-			distributor: distributor,
-			ctx:         ctx,
-			mint:        mint,
-			maxt:        maxt,
-			streaming:   streaming,
-			chunkIterFn: iteratorFn,
-		}, nil
-	})
+func newDistributorQueryable(distributor Distributor, streaming bool, iteratorFn chunkIteratorFunc, queryIngesterWithin time.Duration) QueryableWithFilter {
+	return distributorQueryable{
+		distributor:         distributor,
+		streaming:           streaming,
+		iteratorFn:          iteratorFn,
+		queryIngesterWithin: queryIngesterWithin,
+	}
+}
+
+type distributorQueryable struct {
+	distributor         Distributor
+	streaming           bool
+	iteratorFn          chunkIteratorFunc
+	queryIngesterWithin time.Duration
+}
+
+func (d distributorQueryable) Querier(ctx context.Context, mint, maxt int64) (storage.Querier, error) {
+	return &distributorQuerier{
+		distributor: d.distributor,
+		ctx:         ctx,
+		mint:        mint,
+		maxt:        maxt,
+		streaming:   d.streaming,
+		chunkIterFn: d.iteratorFn,
+	}, nil
+}
+
+func (d distributorQueryable) UseQueryable(now time.Time, _, queryMaxT int64) bool {
+	// Include ingester only if maxt is within QueryIngestersWithin w.r.t. current time.
+	return d.queryIngesterWithin == 0 || queryMaxT >= util.TimeToMillis(now.Add(-d.queryIngesterWithin))
 }
 
 type distributorQuerier struct {
diff --git a/pkg/querier/distributor_queryable_test.go b/pkg/querier/distributor_queryable_test.go
index 80854a7496a..58a461541ef 100644
--- a/pkg/querier/distributor_queryable_test.go
+++ b/pkg/querier/distributor_queryable_test.go
@@ -3,6 +3,7 @@ package querier
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/pkg/labels"
@@ -15,6 +16,7 @@ import (
 	"github.com/cortexproject/cortex/pkg/chunk/encoding"
 	"github.com/cortexproject/cortex/pkg/ingester/client"
 	"github.com/cortexproject/cortex/pkg/prom1/storage/metric"
+	"github.com/cortexproject/cortex/pkg/util"
 	"github.com/cortexproject/cortex/pkg/util/chunkcompat"
 )
 
@@ -38,7 +40,7 @@ func TestDistributorQuerier(t *testing.T) {
 			},
 		},
 	}
-	queryable := newDistributorQueryable(d, false, nil)
+	queryable := newDistributorQueryable(d, false, nil, 0)
 	querier, err := queryable.Querier(context.Background(), mint, maxt)
 	require.NoError(t, err)
 
@@ -57,6 +59,22 @@ func TestDistributorQuerier(t *testing.T) {
 	require.NoError(t, seriesSet.Err())
 }
 
+func TestDistributorQueryableFilter(t *testing.T) {
+	d := &mockDistributor{}
+	dq := newDistributorQueryable(d, false, nil, 1*time.Hour)
+
+	now := time.Now()
+
+	queryMinT := util.TimeToMillis(now.Add(-5 * time.Minute))
+	queryMaxT := util.TimeToMillis(now)
+
+	require.True(t, dq.UseQueryable(now, queryMinT, queryMaxT))
+	require.True(t, dq.UseQueryable(now.Add(time.Hour), queryMinT, queryMaxT))
+
+	// Same query, hour+1ms later, is not sent to ingesters.
+	require.False(t, dq.UseQueryable(now.Add(time.Hour).Add(1*time.Millisecond), queryMinT, queryMaxT))
+}
+
 func TestIngesterStreaming(t *testing.T) {
 	// We need to make sure that there is atleast one chunk present,
 	// else no series will be selected.
@@ -87,7 +105,7 @@ func TestIngesterStreaming(t *testing.T) {
 		},
 	}
 	ctx := user.InjectOrgID(context.Background(), "0")
-	queryable := newDistributorQueryable(d, true, mergeChunks)
+	queryable := newDistributorQueryable(d, true, mergeChunks, 0)
 	querier, err := queryable.Querier(ctx, mint, maxt)
 	require.NoError(t, err)
 
diff --git a/pkg/querier/querier.go b/pkg/querier/querier.go
index 466be918626..95681617fbd 100644
--- a/pkg/querier/querier.go
+++ b/pkg/querier/querier.go
@@ -61,6 +61,9 @@ type Config struct {
 	// Blocks storage only.
 	StoreGatewayAddresses string           `yaml:"store_gateway_addresses"`
 	StoreGatewayClient    tls.ClientConfig `yaml:"store_gateway_client"`
+
+	SecondStoreEngine        string       `yaml:"second_store_engine"`
+	UseSecondStoreBeforeTime flagext.Time `yaml:"use_second_store_before_time"`
 }
 
 var (
@@ -89,6 +92,8 @@ func (cfg *Config) RegisterFlags(f *flag.FlagSet) {
 	f.DurationVar(&cfg.LookbackDelta, "querier.lookback-delta", defaultLookbackDelta, "Time since the last sample after which a time series is considered stale and ignored by expression evaluations.")
 	// TODO: Remove this flag in v1.4.0.
 	f.DurationVar(&cfg.legacyLookbackDelta, "promql.lookback-delta", defaultLookbackDelta, "[DEPRECATED] Time since the last sample after which a time series is considered stale and ignored by expression evaluations. Please use -querier.lookback-delta instead.")
+	f.StringVar(&cfg.SecondStoreEngine, "querier.second-store-engine", "", "Second store engine to use for querying. Empty = disabled.")
+	f.Var(&cfg.UseSecondStoreBeforeTime, "querier.use-second-store-before-time", "If specified, second store is only used for queries before this timestamp. Default value 0 means secondary store is always queried.")
 }
 
 // Validate the config
@@ -127,12 +132,20 @@ func NewChunkStoreQueryable(cfg Config, chunkStore chunkstore.ChunkStore) storag
 }
 
 // New builds a queryable and promql engine.
-func New(cfg Config, distributor Distributor, storeQueryable storage.Queryable, tombstonesLoader *purger.TombstonesLoader, reg prometheus.Registerer) (storage.Queryable, *promql.Engine) {
+func New(cfg Config, distributor Distributor, stores []QueryableWithFilter, tombstonesLoader *purger.TombstonesLoader, reg prometheus.Registerer) (storage.Queryable, *promql.Engine) {
 	iteratorFunc := getChunksIteratorFunction(cfg)
 
-	var queryable storage.Queryable
-	distributorQueryable := newDistributorQueryable(distributor, cfg.IngesterStreaming, iteratorFunc)
-	queryable = NewQueryable(distributorQueryable, storeQueryable, iteratorFunc, cfg, tombstonesLoader)
+	distributorQueryable := newDistributorQueryable(distributor, cfg.IngesterStreaming, iteratorFunc, cfg.QueryIngestersWithin)
+
+	ns := make([]QueryableWithFilter, len(stores))
+	for ix, s := range stores {
+		ns[ix] = storeQueryable{
+			QueryableWithFilter: s,
+			QueryStoreAfter:     cfg.QueryStoreAfter,
+		}
+	}
+
+	queryable := NewQueryable(distributorQueryable, ns, iteratorFunc, cfg, tombstonesLoader)
 
 	lazyQueryable := storage.QueryableFunc(func(ctx context.Context, mint int64, maxt int64) (storage.Querier, error) {
 		querier, err := queryable.Querier(ctx, mint, maxt)
@@ -174,8 +187,17 @@ func createActiveQueryTracker(cfg Config) *promql.ActiveQueryTracker {
 	return nil
 }
 
+// QueryableWithFilter extends Queryable interface with `UseQueryable` filtering function.
+type QueryableWithFilter interface {
+	storage.Queryable
+
+	// UseQueryable returns true if this queryable should be used to satisfy the query for given time range.
+	// Query min and max time are in milliseconds since epoch.
+	UseQueryable(now time.Time, queryMinT, queryMaxT int64) bool
+}
+
 // NewQueryable creates a new Queryable for cortex.
-func NewQueryable(distributor, store storage.Queryable, chunkIterFn chunkIteratorFunc, cfg Config, tombstonesLoader *purger.TombstonesLoader) storage.Queryable {
+func NewQueryable(distributor QueryableWithFilter, stores []QueryableWithFilter, chunkIterFn chunkIteratorFunc, cfg Config, tombstonesLoader *purger.TombstonesLoader) storage.Queryable {
 	return storage.QueryableFunc(func(ctx context.Context, mint, maxt int64) (storage.Querier, error) {
 		now := time.Now()
 
@@ -205,14 +227,16 @@ func NewQueryable(distributor, store storage.Queryable, chunkIterFn chunkIterato
 
 		q.metadataQuerier = dqr
 
-		// Include ingester only if maxt is within QueryIngestersWithin w.r.t. current time.
-		if cfg.QueryIngestersWithin == 0 || maxt >= util.TimeToMillis(now.Add(-cfg.QueryIngestersWithin)) {
+		if distributor.UseQueryable(now, mint, maxt) {
 			q.queriers = append(q.queriers, dqr)
 		}
 
-		// Include store only if mint is within QueryStoreAfter w.r.t current time.
-		if cfg.QueryStoreAfter == 0 || mint <= util.TimeToMillis(now.Add(-cfg.QueryStoreAfter)) {
-			cqr, err := store.Querier(ctx, mint, maxt)
+		for _, s := range stores {
+			if !s.UseQueryable(now, mint, maxt) {
+				continue
+			}
+
+			cqr, err := s.Querier(ctx, mint, maxt)
 			if err != nil {
 				return nil, err
 			}
@@ -405,3 +429,54 @@ func (pss *seriesSetWithFirstSeries) Warnings() storage.Warnings {
 	}
 	return pss.set.Warnings()
 }
+
+type storeQueryable struct {
+	QueryableWithFilter
+	QueryStoreAfter time.Duration
+}
+
+func (s storeQueryable) UseQueryable(now time.Time, queryMinT, queryMaxT int64) bool {
+	// Include this store only if mint is within QueryStoreAfter w.r.t current time.
+	if s.QueryStoreAfter != 0 && queryMinT > util.TimeToMillis(now.Add(-s.QueryStoreAfter)) {
+		return false
+	}
+	return s.QueryableWithFilter.UseQueryable(now, queryMinT, queryMaxT)
+}
+
+type alwaysTrueFilterQueryable struct {
+	storage.Queryable
+}
+
+func (alwaysTrueFilterQueryable) UseQueryable(_ time.Time, _, _ int64) bool {
+	return true
+}
+
+// Wraps storage.Queryable into QueryableWithFilter, with no query filtering.
+func UseAlwaysQueryable(q storage.Queryable) QueryableWithFilter {
+	return alwaysTrueFilterQueryable{Queryable: q}
+}
+
+type useBeforeTimestampQueryable struct {
+	storage.Queryable
+	ts int64 // Timestamp in milliseconds
+}
+
+func (u useBeforeTimestampQueryable) UseQueryable(_ time.Time, queryMinT, _ int64) bool {
+	if u.ts == 0 {
+		return true
+	}
+	return queryMinT < u.ts
+}
+
+// Returns QueryableWithFilter, that is used only if query starts before given timestamp.
+// If timestamp is zero (time.IsZero), queryable is always used.
+func UseBeforeTimestampQueryable(queryable storage.Queryable, ts time.Time) QueryableWithFilter {
+	t := int64(0)
+	if !ts.IsZero() {
+		t = util.TimeToMillis(ts)
+	}
+	return useBeforeTimestampQueryable{
+		Queryable: queryable,
+		ts:        t,
+	}
+}
diff --git a/pkg/querier/querier_test.go b/pkg/querier/querier_test.go
index 382530d61d8..5693ef05cec 100644
--- a/pkg/querier/querier_test.go
+++ b/pkg/querier/querier_test.go
@@ -11,6 +11,8 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/prometheus/prometheus/tsdb"
+	"github.com/prometheus/prometheus/tsdb/chunkenc"
 
 	"github.com/cortexproject/cortex/pkg/chunk/purger"
 
@@ -135,6 +137,11 @@ func TestQuerier(t *testing.T) {
 	var cfg Config
 	flagext.DefaultValues(&cfg)
 
+	const chunks = 24
+
+	// Generate TSDB head with the same samples as makeMockChunkStore.
+	db := mockTSDB(t, model.Time(0), int(chunks*samplesPerChunk), sampleRate, chunkOffset, int(samplesPerChunk))
+
 	for _, query := range queries {
 		for _, encoding := range encodings {
 			for _, streaming := range []bool{false, true} {
@@ -143,10 +150,11 @@ func TestQuerier(t *testing.T) {
 						cfg.IngesterStreaming = streaming
 						cfg.Iterators = iterators
 
-						chunkStore, through := makeMockChunkStore(t, 24, encoding.e)
+						chunkStore, through := makeMockChunkStore(t, chunks, encoding.e)
 						distributor := mockDistibutorFor(t, chunkStore, through)
 
-						queryable, _ := New(cfg, distributor, NewChunkStoreQueryable(cfg, chunkStore), purger.NewTombstonesLoader(nil, nil), nil)
+						queryables := []QueryableWithFilter{UseAlwaysQueryable(NewChunkStoreQueryable(cfg, chunkStore)), UseAlwaysQueryable(db)}
+						queryable, _ := New(cfg, distributor, queryables, purger.NewTombstonesLoader(nil, nil), nil)
 						testQuery(t, queryable, through, query)
 					})
 				}
@@ -155,6 +163,54 @@ func TestQuerier(t *testing.T) {
 	}
 }
 
+func mockTSDB(t *testing.T, mint model.Time, samples int, step, chunkOffset time.Duration, samplesPerChunk int) storage.Queryable {
+	dir, err := ioutil.TempDir("", "tsdb")
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		_ = os.RemoveAll(dir)
+	})
+
+	opts := tsdb.DefaultOptions()
+	opts.WALSegmentSize = -1 // Disable
+	opts.NoLockfile = true
+
+	// We use TSDB head only. By using full TSDB DB, and appending samples to it, closing it would cause unnecessary HEAD compaction, which slows down the test.
+	head, err := tsdb.NewHead(nil, nil, nil, tsdb.ExponentialBlockRanges(opts.MinBlockDuration, 10, 3)[0], dir, chunkenc.NewPool(), opts.StripeSize, opts.SeriesLifecycleCallback)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		_ = head.Close()
+	})
+
+	app := head.Appender()
+
+	l := labels.Labels{
+		{Name: model.MetricNameLabel, Value: "foo"},
+	}
+
+	cnt := 0
+	chunkStartTs := mint
+	ts := chunkStartTs
+	for i := 0; i < samples; i++ {
+		_, err := app.Add(l, int64(ts), float64(ts))
+		require.NoError(t, err)
+		cnt++
+
+		ts = ts.Add(step)
+
+		if cnt%samplesPerChunk == 0 {
+			// Simulate next chunk, restart timestamp.
+			chunkStartTs = chunkStartTs.Add(chunkOffset)
+			ts = chunkStartTs
+		}
+	}
+
+	require.NoError(t, app.Commit())
+	return storage.QueryableFunc(func(ctx context.Context, mint, maxt int64) (storage.Querier, error) {
+		return tsdb.NewBlockQuerier(head, mint, maxt)
+	})
+}
+
 func TestNoHistoricalQueryToIngester(t *testing.T) {
 	testCases := []struct {
 		name                 string
@@ -219,7 +275,7 @@ func TestNoHistoricalQueryToIngester(t *testing.T) {
 				chunkStore, _ := makeMockChunkStore(t, 24, encodings[0].e)
 				distributor := &errDistributor{}
 
-				queryable, _ := New(cfg, distributor, NewChunkStoreQueryable(cfg, chunkStore), purger.NewTombstonesLoader(nil, nil), nil)
+				queryable, _ := New(cfg, distributor, []QueryableWithFilter{UseAlwaysQueryable(NewChunkStoreQueryable(cfg, chunkStore))}, purger.NewTombstonesLoader(nil, nil), nil)
 				query, err := engine.NewRangeQuery(queryable, "dummy", c.mint, c.maxt, 1*time.Minute)
 				require.NoError(t, err)
 
@@ -310,7 +366,7 @@ func TestNoFutureQueries(t *testing.T) {
 				chunkStore := &errChunkStore{}
 				distributor := &errDistributor{}
 
-				queryable, _ := New(cfg, distributor, chunkStore, purger.NewTombstonesLoader(nil, nil), nil)
+				queryable, _ := New(cfg, distributor, []QueryableWithFilter{UseAlwaysQueryable(chunkStore)}, purger.NewTombstonesLoader(nil, nil), nil)
 				query, err := engine.NewRangeQuery(queryable, "dummy", c.mint, c.maxt, 1*time.Minute)
 				require.NoError(t, err)
 
@@ -501,7 +557,7 @@ func TestShortTermQueryToLTS(t *testing.T) {
 				chunkStore := &emptyChunkStore{}
 				distributor := &errDistributor{}
 
-				queryable, _ := New(cfg, distributor, NewChunkStoreQueryable(cfg, chunkStore), purger.NewTombstonesLoader(nil, nil), nil)
+				queryable, _ := New(cfg, distributor, []QueryableWithFilter{UseAlwaysQueryable(NewChunkStoreQueryable(cfg, chunkStore))}, purger.NewTombstonesLoader(nil, nil), nil)
 				query, err := engine.NewRangeQuery(queryable, "dummy", c.mint, c.maxt, 1*time.Minute)
 				require.NoError(t, err)
 
@@ -525,5 +581,55 @@ func TestShortTermQueryToLTS(t *testing.T) {
 			})
 		}
 	}
+}
+
+func TestUseAlwaysQueryable(t *testing.T) {
+	m := &mockQueryableWithFilter{}
+	qwf := UseAlwaysQueryable(m)
+
+	require.True(t, qwf.UseQueryable(time.Now(), 0, 0))
+	require.False(t, m.useQueryableCalled)
+}
+
+func TestUseBeforeTimestamp(t *testing.T) {
+	m := &mockQueryableWithFilter{}
+	now := time.Now()
+	qwf := UseBeforeTimestampQueryable(m, now.Add(-1*time.Hour))
+
+	require.False(t, qwf.UseQueryable(now, util.TimeToMillis(now.Add(-5*time.Minute)), util.TimeToMillis(now)))
+	require.False(t, m.useQueryableCalled)
+
+	require.False(t, qwf.UseQueryable(now, util.TimeToMillis(now.Add(-1*time.Hour)), util.TimeToMillis(now)))
+	require.False(t, m.useQueryableCalled)
+
+	require.True(t, qwf.UseQueryable(now, util.TimeToMillis(now.Add(-1*time.Hour).Add(-time.Millisecond)), util.TimeToMillis(now)))
+	require.False(t, m.useQueryableCalled) // UseBeforeTimestampQueryable wraps Queryable, and not QueryableWithFilter.
+}
+
+func TestStoreQueryable(t *testing.T) {
+	m := &mockQueryableWithFilter{}
+	now := time.Now()
+	sq := storeQueryable{m, time.Hour}
+
+	require.False(t, sq.UseQueryable(now, util.TimeToMillis(now.Add(-5*time.Minute)), util.TimeToMillis(now)))
+	require.False(t, m.useQueryableCalled)
+
+	require.False(t, sq.UseQueryable(now, util.TimeToMillis(now.Add(-1*time.Hour).Add(time.Millisecond)), util.TimeToMillis(now)))
+	require.False(t, m.useQueryableCalled)
+
+	require.True(t, sq.UseQueryable(now, util.TimeToMillis(now.Add(-1*time.Hour)), util.TimeToMillis(now)))
+	require.True(t, m.useQueryableCalled) // storeQueryable wraps QueryableWithFilter, so it must call its UseQueryable method.
+}
+
+type mockQueryableWithFilter struct {
+	useQueryableCalled bool
+}
+
+func (m *mockQueryableWithFilter) Querier(_ context.Context, _, _ int64) (storage.Querier, error) {
+	return nil, nil
+}
 
+func (m *mockQueryableWithFilter) UseQueryable(_ time.Time, _, _ int64) bool {
+	m.useQueryableCalled = true
+	return true
 }
diff --git a/pkg/util/flagext/time.go b/pkg/util/flagext/time.go
new file mode 100644
index 00000000000..452857e9de8
--- /dev/null
+++ b/pkg/util/flagext/time.go
@@ -0,0 +1,60 @@
+package flagext
+
+import (
+	"fmt"
+	"time"
+)
+
+// Time usable as flag or in YAML config.
+type Time time.Time
+
+// String implements flag.Value
+func (t Time) String() string {
+	if time.Time(t).IsZero() {
+		return "0"
+	}
+
+	return time.Time(t).Format(time.RFC3339)
+}
+
+// Set implements flag.Value
+func (t *Time) Set(s string) error {
+	if s == "0" {
+		*t = Time(time.Time{})
+		return nil
+	}
+
+	p, err := time.Parse("2006-01-02", s)
+	if err == nil {
+		*t = Time(p)
+		return nil
+	}
+
+	p, err = time.Parse("2006-01-02T15:04", s)
+	if err == nil {
+		*t = Time(p)
+		return nil
+	}
+
+	p, err = time.Parse("2006-01-02T15:04:05Z07:00", s)
+	if err == nil {
+		*t = Time(p)
+		return nil
+	}
+
+	return fmt.Errorf("failed to parse time: %q", s)
+}
+
+// UnmarshalYAML implements yaml.Unmarshaler.
+func (t *Time) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var s string
+	if err := unmarshal(&s); err != nil {
+		return err
+	}
+	return t.Set(s)
+}
+
+// MarshalYAML implements yaml.Marshaler.
+func (t Time) MarshalYAML() (interface{}, error) {
+	return t.String(), nil
+}
diff --git a/pkg/util/flagext/time_test.go b/pkg/util/flagext/time_test.go
new file mode 100644
index 00000000000..b34942b6eda
--- /dev/null
+++ b/pkg/util/flagext/time_test.go
@@ -0,0 +1,80 @@
+package flagext
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v2"
+)
+
+func TestTimeYAML(t *testing.T) {
+	{
+		type TestStruct struct {
+			T Time `yaml:"time"`
+		}
+
+		var testStruct TestStruct
+		require.NoError(t, testStruct.T.Set("2020-10-20"))
+
+		marshaled, err := yaml.Marshal(testStruct)
+		require.NoError(t, err)
+
+		expected := `time: "2020-10-20T00:00:00Z"` + "\n"
+		assert.Equal(t, expected, string(marshaled))
+
+		var actualStruct TestStruct
+		err = yaml.Unmarshal([]byte(expected), &actualStruct)
+		require.NoError(t, err)
+		assert.Equal(t, testStruct, actualStruct)
+	}
+
+	{
+		type TestStruct struct {
+			T *Time `yaml:"time"`
+		}
+
+		var testStruct TestStruct
+		testStruct.T = &Time{}
+		require.NoError(t, testStruct.T.Set("2020-10-20"))
+
+		marshaled, err := yaml.Marshal(testStruct)
+		require.NoError(t, err)
+
+		expected := `time: "2020-10-20T00:00:00Z"` + "\n"
+		assert.Equal(t, expected, string(marshaled))
+
+		var actualStruct TestStruct
+		err = yaml.Unmarshal([]byte(expected), &actualStruct)
+		require.NoError(t, err)
+		assert.Equal(t, testStruct, actualStruct)
+	}
+}
+
+func TestTimeFormats(t *testing.T) {
+	ts := &Time{}
+	require.NoError(t, ts.Set("0"))
+	require.True(t, time.Time(*ts).IsZero())
+	require.Equal(t, "0", ts.String())
+
+	require.NoError(t, ts.Set("2020-10-05"))
+	require.Equal(t, mustParseTime(t, "2006-01-02", "2020-10-05").Format(time.RFC3339), ts.String())
+
+	require.NoError(t, ts.Set("2020-10-05T13:27"))
+	require.Equal(t, mustParseTime(t, "2006-01-02T15:04", "2020-10-05T13:27").Format(time.RFC3339), ts.String())
+
+	require.NoError(t, ts.Set("2020-10-05T13:27:00Z"))
+	require.Equal(t, mustParseTime(t, "2006-01-02T15:04:05Z", "2020-10-05T13:27:00Z").Format(time.RFC3339), ts.String())
+
+	require.NoError(t, ts.Set("2020-10-05T13:27:00+02:00"))
+	require.Equal(t, mustParseTime(t, "2006-01-02T15:04:05Z07:00", "2020-10-05T13:27:00+02:00").Format(time.RFC3339), ts.String())
+}
+
+func mustParseTime(t *testing.T, f, s string) time.Time {
+	ts, err := time.Parse(f, s)
+	if err != nil {
+		t.Fatalf("failed to parse %q: %v", s, err)
+	}
+	return ts
+}
diff --git a/tools/doc-generator/parser.go b/tools/doc-generator/parser.go
index 181595eda62..14b224b65d2 100644
--- a/tools/doc-generator/parser.go
+++ b/tools/doc-generator/parser.go
@@ -369,6 +369,22 @@ func getCustomFieldEntry(field reflect.StructField, fieldValue reflect.Value, fl
 			fieldDefault: fieldFlag.DefValue,
 		}, nil
 	}
+	if field.Type == reflect.TypeOf(flagext.Time{}) {
+		fieldFlag, err := getFieldFlag(field, fieldValue, flags)
+		if err != nil {
+			return nil, err
+		}
+
+		return &configEntry{
+			kind:         "field",
+			name:         getFieldName(field),
+			required:     isFieldRequired(field),
+			fieldFlag:    fieldFlag.Name,
+			fieldDesc:    fieldFlag.Usage,
+			fieldType:    "time",
+			fieldDefault: fieldFlag.DefValue,
+		}, nil
+	}
 
 	return nil, nil
 }