There is a real sense of vibrancy around Bordeaux’s Right Bank to excite collectors at all levels, propelled by vineyard investment, a run of good vintages and demand for some top-tier labels on the market.
This report focuses on St-Emilion and Pomerol reds, drawing on previous exclusive reporting for Decanter Premium subscribers to highlight recent developments and offer an introductory guide to the region’s position on the fine wine market.
Market Fundamentals
{"content":"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"}