Nothing marks the end of summer like the school’s re-opening and the start of the annual September releases campaign.
This is the second tranche of international releases, or ‘Hors Bordeaux’, following the 50+ wines launched by négociants in March.
{"content":"</p>
<hr>
<h2 style="text-align: center"><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/september-releases-on-the-place-de-bordeaux-2025-score-table/">SCORE TABLE: All the Place de Bordeaux September releases</a><br />
Scroll down for Georgie&#8217;s &#8216;ultimate autumn case&#8217;</h2>
<hr>
<p>It’s no secret that the <a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/premium/wine-investment-fine-wine-prices-continue-to-fall-562447/" target="_blank" rel="noopener"><strong>fine wine market is struggling at the moment</strong></a>, amid a backdrop of lingering US tariffs, a subdued Chinese market, and broader economic headwinds.</p>
<p>However, the 2025 campaign underscores the resilience, perseverance and prestige of La Place delivering a crafted &#8211; and increased &#8211; number of fine wines from around the world.</p>
<p><div class="ad-container ad-container--mobile"><div id="post-inline-2" class="ipc-advert"></div></div></p>
<p>The autumn releases also present a joyous and fascinating moment to check in on both new and old vintages from some of the world’s most iconic and reputable estates. And this year’s cohort is a bounty of beautiful wines waiting to be explored.</p>
<p>The campaign, that technically kicked off on 28 August with Domaine de Baronarques, will run through to the end of September (with some extensions into October) and features more than 130 wines from 12 countries including: Italy, Spain, the US, Germany, Chile, Argentina, Australia, Austria, Hungary, South Africa and France.</p>
<p>The calendar of releases takes on a clearer structure than in previous years with the coming days seeing the release of starry names like Opus One (1 September), Masseto today (2 September), Almaviva (3 September), Solaia (4 September), and Penfolds Grange (8 September), alongside Bordeaux gems such as the historic re-releases from Latour (2012) and Palmer (2015).</p>
<div class="ad-container ad-container--mobile"><div id="post-inline-3" class="ipc-advert"></div></div>
<p>The releases will be split by region giving each country the limelight – Australia, Spain, Italy, US, France then South America – with a dedicated Riesling week in October like last year.</p>
<h2>New and exciting wines</h2>
<p>Akin to last year’s flurry of German Rieslings entering La Place, this year is the first time wines from the Loire Valley will be included alongside other French bottlings. It&#8217;s an exciting development that seeks to not only present the best of France all in one accessible place but also offer more white wines satisfying current market trends and demand.</p>
<div class="ad-container ad-container--mobile"><div id="post-inline-4" class="ipc-advert"></div></div>
<p>The number of wines due to be released may also give way to a potential dedicated ‘Loire week’ within the campaign.</p>
<p>Jean-Quentin Prats, CEO of Joanne Rare Wines which manages more than 100 ‘Hors Bordeaux’ wines, captures this strategy: ‘We want to focus on establishing what we already have however if there was one area we could increase, it was white.&#8217;</p>
<div class="ad-container ad-container--mobile"><div id="post-inline-5" class="ipc-advert"></div></div>
<p>Indeed there are five new white wines on offer this autumn. ‘[There is an] increase in French whites, and one area is the Loire Valley where you have very high-quality products, old vines on amazing soils and great know-how. And there is a demand in the market for that,’ Prats added.</p>
<p>Alongside the Loire wines including; Domaine Delaporte (three cuvées from Sancerre), Domaine Sébastian Brunet (old-vine Chenin in Vouvray) and Luneau-Papin (biodynamic wine from Muscadet), are new wines from Adega Algueira (Cornamuse Godello from Ribeira Sacra), a sublime Chardonnay from Zuccardi (Gualtallary), the excellent House of Arras Late Disgorged Grand Vintage 2008 (Tasmania), an 18-year-old Riesling from Jim Barry (Clare Valley) and a red and white from <a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/premium/sonoma-coasts-flowers-winery-producer-profile-and-wines-to-try-512257/" target="_blank" rel="noopener"><strong>Sonoma’s Flowers Winery</strong></a>.</p>
<p>Despite global challenges – declining wine consumption, tariff-driven price hikes, and shifting demand – La Place remains a dynamic stage for producers’ unwavering commitment to excellence and the increase in wines showcases that.</p>
<p>This campaign is a heartening reminder of the resilience of wineries and merchants striving to spotlight world-class wines (at a mixture of price points), in a turbulent market.</p>
<h2>My highlights</h2>
<h3>Australia</h3>
<div id="attachment_561510" style="width: 1310px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" aria-describedby="caption-attachment-561510" class="lazyload blur-up size-full wp-image-561510" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange.jpg" alt="Penfolds-2025-Collection-Tasting-Grange" width="1300" height="860" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange.jpg 1300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-300x198.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-630x417.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-135x89.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-320x212.jpg 320w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-620x410.jpg 620w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-920x609.jpg 920w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/07/Penfolds-2025-Collection-Tasting-Grange-1220x807.jpg 1220w" sizes="(max-width: 1300px) 100vw, 1300px" /><p id="caption-attachment-561510" class="wp-caption-text">Seven decades on from its first iteration, the 2021 vintage of Grange was a highlight of the 2025 Penfolds Collection.</p></div>
<p>There are several superlative wines in the mix this year starting with the 100-point Cloudburst Chardonnay from the 2023 vintage. It was tasted at the end of a 10-year-vertical, which will be coming to <em>Decanter</em> Premium this month, and showcases the very best of what owner and winemaker Will Berliner can achieve with his vineyard-come-garden. A sublime wine.</p>
<p>More white Australia gems come in the form of aged Tasmania sparkling House of Arras 2008 which was utterly delightful, Giaconda’s Chardonnay is another knockout by winemaker Rick Kinzbrunner and Jim Barry’s Florita Riesling 2015 is well worth seeking out.</p>
<p>For the reds, <a href="http://decanter.com/premium/penfolds-collection-2025-grange-2021-tops-milestone-releases-561479/?cx_testId=1&amp;cx_testVariant=cx_1&amp;cx_artPos=2&amp;cx_experienceId=EX518LXBMFJX&amp;cx_experienceActionId=showRecommendationsHT3QUFJV91LX37&amp;cxTrackingId=%7Bkpdx%7DAAAAwCSkYgrwawoKNnF2OE9uaUtRTxIQbWYyOXAwbzZnZzdyZzh0NBoMRVg1MThMWEJNRkpYIiUxODA1YTJvMGJrLTAwMDAzNjg5ZjRvbGV2MHJrdG85cDM3ZGUwKiFzaG93UmVjb21tZW5kYXRpb25zSFQzUVVGSlY5MUxYMzdSEnYtbADwM291ZTdqczJ5OGdnZVolMmEwMTplMGE6MWVjOmJkOTA6YWQ1NTphZGQ5OjhjMTc6ZjU4Y2IDZG1jaLHv38UGcAR4GA#cxrecs_s" target="_blank" rel="noopener"><strong>Penfolds Grange</strong> </a>is absolutely top class as is Jim Barry’s The Armagh – exceptionally captivating and great quality.</p>
<h3>Argentina</h3>
<p>I completely fell in love with Sebastian Zuccardi’s Finca Canal Uco stopping just short of 100-points. It’s an amazingly fresh and focussed Malbec from high-altitude vineyards in Paraje Altamira. I’ve met Sebastian a few times in Bordeaux to taste through his ever-expanding range of wines and I adore his approach and sensitivity to the cuvées he creates.</p>
<p>The accolades continue for Argentina with a brilliant Cheval des Andes and fabulous Catena Zapata Adrianna Vineyard.</p>
<h3>Austria</h3>
<p>How lucky we are that Gerhard Kracher’s wines are now on the Place de Bordeaux. It’s a little tricky keeping up with the dozen or so Trockenbeerenauslese cuvées he produces (among lots of others) each year of which a selection are chosen to present to La Place.</p>
<p>This year there are five wines – numbered in order of sweetness – the denser a wine, the higher the number. If you haven’t tried these wines before don’t hesitate. They’re all excellent with numbers two, three and five standouts among the impressive range.</p>
<div id="attachment_564114" style="width: 633px" class="wp-caption alignnone"><img decoding="async" aria-describedby="caption-attachment-564114" class="lazyload blur-up size-large wp-image-564114" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-623x830.jpg" alt="The Kracher releases on the Place de Bordeaux in September 2025" width="623" height="830" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-623x830.jpg 623w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-300x400.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-101x135.jpg 101w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-240x320.jpg 240w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-465x620.jpg 465w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher-690x920.jpg 690w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Kracher.jpg 700w" sizes="(max-width: 623px) 100vw, 623px" /><p id="caption-attachment-564114" class="wp-caption-text">The Kracher releases on the Place de Bordeaux in September 2025</p></div>
<h3>Chile</h3>
<p>Ever since I visited Chile – and all of the La Place producers bar Vik in 2022 – I’ve been captivated by what&#8217;s being produced there.</p>
<p>Seeing the magnificent vineyard vistas and getting to know the viticulture and terroir helped me understand the efforts that are going on in the country to create world-class wines.</p>
<p>Seña this year is absolutely incredible – a must-buy if you can, but Almaviva and Santa Rita are also excellent. I also love the work Sebastian Labbé is doing at Viña Santa Rita wtih Casa Real. Such attention to detail is showcased in the wines.</p>
<div id="attachment_564109" style="width: 640px" class="wp-caption alignnone"><img decoding="async" aria-describedby="caption-attachment-564109" class="lazyload blur-up size-large wp-image-564109" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real-630x484.jpg" alt="Sebastián Labbé at Viña Santa Rita with the new Casa Real release" width="630" height="484" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real-630x484.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real-300x231.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real-135x104.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real-320x246.jpg 320w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real-620x477.jpg 620w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Casa-Real.jpg 900w" sizes="(max-width: 630px) 100vw, 630px" /><p id="caption-attachment-564109" class="wp-caption-text">Sebastián Labbé at Viña Santa Rita with the new Casa Real release</p></div>
<h3>France</h3>
<p>The French contingent is strong and varied this year with everything from Champagne to Burgundy to Bordeaux as well as the Loire Valley providing plenty of enjoyment and value – particularly for two first timers.</p>
<p>Cuvée Eugenie, the Pouilly-Fumé from Domaine Lebrun delights with richness and juiciness while the benchmark producer Domaine Luneau-Papin, with ninth generation Pierre-Marie and daughter-in-law Marie at the helm, have produced a lovely and very drinkable biodynamic Gula Ana 2023 for its first outing on La Place.</p>
<p>There are eight Champagnes being released this month spanning six different vintages giving fizz lovers plenty to get stuck into.</p>
<p>My personal favourite was Philipponnat’s mature Clos des Goisses 2000 which is in its peak drinking window, but Leclerc Briant’s organic Château d’Avize 2015 is also captivating, with amazing acidity.</p>
<p>Clos Lanson&#8217;s 2011 is accessible and easy to drink and sits well within the list of back vintages, all tasted together in July (2011, 2010, 2009, 2008, 2007 and 2006). The vertical will be written up in a dedicated article on <em>Decanter</em> Premium later this month.</p>
<div id="attachment_564110" style="width: 640px" class="wp-caption alignnone"><img loading="lazy" decoding="async" aria-describedby="caption-attachment-564110" class="lazyload blur-up size-large wp-image-564110" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-630x388.jpg" alt="Some of the Champagne releases on the Place de Bordeaux in September 2025" width="630" height="388" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-630x388.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-300x185.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-135x83.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-320x197.jpg 320w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-620x382.jpg 620w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-920x566.jpg 920w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes-1220x751.jpg 1220w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Champagne-releaes.jpg 1300w" sizes="(max-width: 630px) 100vw, 630px" /><p id="caption-attachment-564110" class="wp-caption-text">Some of the Champagne releases on the Place de Bordeaux in September 2025</p></div>
<p>In Bordeaux, the new vintage of Château Cheval Blanc’s Le Petit Cheval Blanc is as good as it&#8217;s ever produced – even more evident after tasting back vintages to 2018 – another tasting that will appear on <em>Decanter</em> this month.</p>
<p>Always anticipated, Château d’Yquem’s off-dry ‘Y’ 2023 is stunning as is Château Rieussec’s 2023 vintage. Bordeaux&#8217;s sweet wines might not always get the limelight – and these are just two of the varied options coming from the lauded appellation – but it&#8217;s a great reminder of the enjoyment that these wines can bring whether you drink them young or old.</p>
<p>I tasted a 1975 – 50-year-old Rieussec at the estate last week and it was utterly delicious.</p>
<p>I have yet to taste Château Palmer’s 10-year-on release or Château Latour’s 2012.</p>
<p>Château d’Aussieres, the Languedoc estate from Lafite Rothschild, is packed full of flavour but silky and smooth with lots to like. Great drinkability and value.</p>
<h3>Germany</h3>
<p>I missed Germany entry onto La Place last year as I had just given birth, but there are some stunning wines that deserve greater visibility and appreciation.</p>
<p>Sweet, or even off-dry, wines don’t always have the best reputation, and can often be a hard sell ,but there’s something magical when sweetness and richness meet racy acidity, energy and vibrancy like several do in the list.</p>
<p>Heavyweights Ernst Loosen, Schloss Johannisberg, Steinmetz and Domäne Serrig are all represented this autumn.</p>
<p>I loved Ernie’s Riesling Auslese and Domäne Serrig’s Grosse Lage – both excellent quality and with interesting, historical stories behind them. Seek them out.</p>
<div id="attachment_564112" style="width: 633px" class="wp-caption alignnone"><img loading="lazy" decoding="async" aria-describedby="caption-attachment-564112" class="lazyload blur-up size-large wp-image-564112" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-623x830.jpg" alt="Some of the German Rieslings entering the Place de Bordeaux this September" width="623" height="830" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-623x830.jpg 623w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-300x400.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-101x135.jpg 101w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-240x320.jpg 240w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-465x620.jpg 465w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings-690x920.jpg 690w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/German-Rieslings.jpg 700w" sizes="(max-width: 623px) 100vw, 623px" /><p id="caption-attachment-564112" class="wp-caption-text">Some of the German Rieslings entering the Place de Bordeaux this September</p></div>
<h3>Italy</h3>
<p>Most of the Italian wines were tasted by both myself and <em>Decanter</em>’s Italy editor James Button who came to Bordeaux for the tasting.</p>
<p>Standouts come in the form of Bibi Graetz’s Testamatta and Colore, both brilliant and worth getting hold of.</p>
<p>Antinori’s Solaia and Masseto’s grand vin deliver once again, both with 98 points and one of my favourite wines ever Allegrini’s Fieramonte is un-put-down-able.</p>
<p>I also tasted the new trio of impressive Caiarossa wines which offer great value as well as a mini-vertical of Gianni Mazzei’s Concerto which was extremely impressive. The new vintage doesn&#8217;t quite reach the heights of last year but there&#8217;s a wonderful signature to this wine with extreme drinkability.</p>
<div id="attachment_564108" style="width: 610px" class="wp-caption alignnone"><img loading="lazy" decoding="async" aria-describedby="caption-attachment-564108" class="lazyload blur-up size-full wp-image-564108" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Caiarossa.jpg" alt="The trio of new Caiarossa releases" width="600" height="800" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Caiarossa.jpg 600w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Caiarossa-300x400.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Caiarossa-101x135.jpg 101w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Caiarossa-240x320.jpg 240w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Caiarossa-465x620.jpg 465w" sizes="(max-width: 600px) 100vw, 600px" /><p id="caption-attachment-564108" class="wp-caption-text">The trio of new Caiarossa releases</p></div>
<h3>Spain</h3>
<p>Telmo Rodriguez’s Yjar (Rioja) and Matallana from Ribera del Duero are both worth trying to get hold of, as is the new complex and enjoyable wine from Adega Algueira – Cornamuse from Ribeira Sacra.</p>
<p>Despite the challengingly hot conditions, CVNE has produced a concentrated but balanced and finessed Real de Asúa Carromaza 2022.</p>
<h3>USA</h3>
<p>North American wines make up the bulk of the releases, many from the hot and dry 2022 vintage of which several were covered by Jonathan Cristaldi in his <a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/napa-valley-cabernet-2022-report/"><strong>Napa Valley vintage 2022 report</strong></a>.</p>
<p>Highlights for me include the ever-brilliant Dalla Valle Vineyards Maya 2022 and an exceptional Quintessa 2022.</p>
<p>I also loved Luc Morlet’s slightly older 2018 vintage of Coeur de Vallée Cabernet Sauvignon and all three Verité wines from Sonoma.</p>
<p>The final La Place vertical to accompany this report will come in the form of 10 vintages of Inglenook&#8217;s Rubicon. I was lucky enough to attend a masterclass with winemaker Philippe Bascaules in July where we tasted vintages back to 2013.</p>
<p>This wine is really hitting its stride with a wonderful energetic quality to the wine despite the tough conditions.</p>
<div id="attachment_564113" style="width: 640px" class="wp-caption alignnone"><img loading="lazy" decoding="async" aria-describedby="caption-attachment-564113" class="lazyload blur-up size-large wp-image-564113" data-processed src="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering/wp-content/themes/simba-theme/assets/images/placeholder.png" data-src="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-630x417.jpg" alt="A vertical of Inglenook Rubicon ahead of the 2022 vintage release on the Place de Bordeaux " width="630" height="417" data-sizes="auto" data-srcset="https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-630x417.jpg 630w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-300x198.jpg 300w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-135x89.jpg 135w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-320x212.jpg 320w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-620x410.jpg 620w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-920x609.jpg 920w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon-1220x807.jpg 1220w, https://keyassets.timeincuk.net/inspirewp/live/wp-content/uploads/sites/34/2025/09/Inglenook-Rubicon.jpg 1300w" sizes="(max-width: 630px) 100vw, 630px" /><p id="caption-attachment-564113" class="wp-caption-text">A vertical of Inglenook Rubicon ahead of the 2022 vintage release on the Place de Bordeaux</p></div>
<h2>Where value and interest lie</h2>
<p>In a market favouring affordability, look to under £40 releases from Spain (Dolio) and southern Italy for everyday luxury as well as some of the German Rieslings which have incredible quality to price ratios. The wines from the Loire and Languedoc also provide excellent value.</p>
<p>Given the nature and prestige of some of these wines, prices can be on the very high side with the most expensive likely to top US$400-500. That said, if money were no object these would be my top 12 picks.</p>
<hr>
<div class="breakout palette-a panel panel-default"><div class="panel-body"><div class='breakout-content'></p>
<h2 style="text-align: center">Which wines should you buy? My ultimate case of 12:</h2>
<p><em>Ordered by style and score; sparkling, white, red, sweet.</em></p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/australia/tasmania/house-of-arras-e-j-carr-late-disgorged-tasmania-2008-100318">House of Arras E.J. Carr 2008</a> (97-points):</strong> Vibrant Tasmanian fizz.</p>
<p><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/france/champagne/philipponnat-clos-de-goisses-lv-extra-brut-champagne-2000-100287"><strong>Philipponnat, Clos de Goisses LV Extra Brut 2000</strong></a> <strong>(98-points):</strong> Mature and mouthwatering.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/australia/western-australia/cloudburst-chardonnay-margaret-river-2023-100277">Cloudburst, Chardonnay 2023</a> (100-points):</strong> Sublime, vibrant, and complex.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/france/bordeaux/chateau-dyquem-ygrek-bordeaux-blanc-bordeaux-2023-100317">Château d’Yquem, Ygrek 2023</a> (96-points):</strong> Fresh, succulent and moreish</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/italy/tuscany/bibi-graetz-colore-toscana-tuscany-italy-2023-100073">Bibi Graetz, Colore 2023</a> (99-points):</strong> Nuanced and spectacular.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/australia/south-australia/jim-barry-the-armagh-shiraz-clare-valley-2022-100262">Jim Barry, The Armagh Shiraz 2022</a> (99-points):</strong> Bottled happiness.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/chile/aconcagua-valley/sena-sena-aconcagua-valley-chile-2023-100327">Seña 2023</a> (99-points):</strong> Incredible Bordeaux-style blend.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/usa/california/quintessa-napa-valley-rutherford-california-usa-2022-82076">Quintessa 2022</a> (99-points):</strong> Classy and energetic.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/argentina/mendoza/zuccardi-finca-canal-uco-uco-valley-paraje-altamira-2022-100244">Zuccardi, Finca Canal Uco 2022</a> (99-points):</strong> Fresh, focused Malbec.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/usa/california/dalla-valle-vineyards-maya-napa-valley-california-2022-100261">Dalla Valle Vineyards, Maya 2022</a> (98-points):</strong> Seductive and bold.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/austria/burgenland/kracher-nummer-3-grande-cuvee-trockenbeerenauslese-2022-100290">Kracher, Nummer 3 TBA 2022</a> (98-points):</strong> Exotic and zingy.</p>
<p><strong><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/wine-reviews/germany/mosel/dr-loosen-weingut-zacharias-bergweiler-pruem-erben-riesling-100297">Dr Loosen, Riesling Auslese 2019</a> (98-points):</strong> Dense yet invigorating. </p>
</div><div class='breakout-buttons'><div class='row'></div></div></div></div>
<hr>
<h2>History of the releases</h2>
<p>Beginning as a niche extension to Bordeaux’s en primeur system, the twice yearly ‘Hors Bordeaux’ releases have grown into a global fine wine powerhouse providing international producers access to premium markets via the region’s efficient distribution network.</p>
<p>Collectors can secure allocations at ex-cellar prices, often with ageing potential that drives secondary market value. These releases, many of which are actually back vintages, will test the market sentiment post a lacklustre Bordeaux 2024 en primeur campaign that failed to ignite serious enthusiasm despite some heavy discounts on 2023 release prices.</p>
<p>Generally a good indicator of enthusiasm is the appeal for Opus on the 1st of the month, this year releasing at a recommended UK onward selling price of £235 (8% down on the 2021 / 6% down on the 2019 according to Wine Lister.</p>
<p>It comes to the market below all recent back vintages. The consulting, data and analytics company said: ‘As one of September&#8217;s perennial best sellers, if any release has a chance of seeing demand in this difficult market, it&#8217;s Opus One.’</p>
<p>One courtier noted: ‘Everyone is waiting to see what the release prices for Opus and Almaviva will be – if they’re good for the market and people buy it will create a dynamic demand’.</p>
<div class="injection"></div>
<p>It’s not just about price however, similar to the Bordeaux 2024s. There will be brands who have to decrease and some who will hold firm from strategy or lack of increase over the years. Let’s hope there’s some rebounding for this collection of wines.</p>
<h3>Yet to be tasted</h3>
<ul>
<li>Pym Rae, Mount Veeder, Napa Valley 2021</li>
<li>Klein Constantia, Vin de Constance, Constantia, 2022</li>
<li>Quintessa, Illumination, Sonoma County, 2024</li>
<li>Flowers, Chardonnay, Sonoma Coast, 2023</li>
<li>Château Palmer, Margaux 3éme Grand Cru Classe, 2015</li>
<li>Château Latour, 1er Grand Cru Classe, Pauillac, 2012</li>
</ul>
<p><em>Additional tasting notes for this report were done by Tina Gellie, James Button, Ines Salpico,  Jonathan Cristaldi. In some instances there may be two tasting notes.</em></p>
<hr>
<h2 style="text-align: center"><a href="https://www.decanter.com.master.public.keystone-prod-eks-euw1.futureplc.engineering.master.public.keystone-prod-eks-euw1.futureplc.engineering/september-releases-on-the-place-de-bordeaux-2025-score-table/">SCORE TABLE: All the Place de Bordeaux September releases:</a></h2>
<p>
"}