
<p class="has-drop-cap wp-block-paragraph">1 För sex år sedan (2019) var det premiär för matchen mellan varmblod och kallblod på Umåker, nämligen Hot’n Cold. Första upplagan togs hem av <strong>Eder Bob </strong>(e. Crazed), som startade 460 respektive 440 meter bakom kallbloden. Ikväll på <strong>Umåker</strong> (start 18.20) är det dags för årets upplaga.</p>



<p class="wp-block-paragraph">Det har skruvats lite på propositionen under årens lopp, där vinnarna efter sex år är jämnt fördelade mellan raserna: 3–3.</p>



<p class="wp-block-paragraph">Efter att ha bjudit 75.000 kronor till vinnaren är loppet i år rejält devalverat till 35.000 kronor i förstapris. <strong>Nordprins</strong> (e. Tekno Odin) på startfållan 2.140 meter samt <strong>Guli Theo</strong> (e. Lome Kongen) och <strong>Granbarksborren (</strong>e. Bork Odin) 20 meter bakom jagas av fem varmblod från distansen 2.540 meter. Bland dessa finns femfaldige miljonären <strong>Global Adventure</strong> (e. S.J.s Caviar).</p>



<p class="wp-block-paragraph">Medan nioårige Global Adventure har seger i Svampen som tvååring och andraplatser i Breeders Crown och korta E3 som treåring på meritlistan, så kommer Granbarksborren närmast från start i Svenskt Kallblodsderby för sex dagar sedan, där han slutade oplacerad.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 Flera färska klassiska storloppsfinalister dyker upp på kvällens saxbana <strong>Bollnäs</strong> (start 17.45). Både <strong>Hertiginnan Stöen</strong> (e. Tekno Odin) och <strong>Björgen</strong> (e. Bork Odin) var hårt betrodda i Derbystoet, men gick lottlösa från finalen. Det gjorde däremot inte <strong>Eld Prinsessa </strong>(e. Tekno Odin), som slutade femma. Ikväll möts de tre stona igen i ett sprinterlopp med fyraåriga ston på fyra volter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/hertiginnanstoen-617x333.jpg" alt="" class="wp-image-753229"/><figcaption class="wp-element-caption">Hertiginnan Stöen och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Även tre finalister från Svenskt Kallblodskriterium/Kriteriestoet drabbar samman i ett treåringslopp, där Oskar Kylin Bloms <strong>Kattelbo Elon</strong> (e. Tekno Odin) lyckades bäst i storloppsfinalerna på Dannero med fjärdeplatsen i Kriteriet.</p>



<p class="wp-block-paragraph">Dessa ställs mot en av svenska kullens absoluta toppar i <strong>G.G. Xtrem</strong> (e. Grisle Odin G.L.), som inte var anmäld till Kriteriet.</p>



<p class="wp-block-paragraph">Fredagen inleds med lunchtävlingar i <strong>Kalmar </strong>(start 12.20), där <strong>Nikki Lane</strong> (e. Maharajah) återkommer efter kortare uppehåll. Förra året vann hon dubbla försök i Diamantstoet. Hon startar 20 meter bakom Eric Martinssons formstarka dam <strong>Tui Southwind</strong> (e. Readly Express).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/08/250815.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/08/250815.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3 Propositionerna till den första V85-omgången är klara. Jägersro står som värd för den första omgången – lördagen den 25 oktober – och tio lopp finns utskrivna på programmet. Första start sker klockan 15.20 (kl. 14.45 idag) och banans sportchef Mats Ahlqvist gläds i första hand åt två saker.</p>



<p class="wp-block-paragraph">– Jättekul att vi får en ny historisk premiär på Jägersro och inte minst eftersom vi hade V75-premiären här också. Nummer två är att vi faktiskt satsat lite extra på den här dagen och detta innan vi fick besked om att första V85-omgången skulle hållas här. Vi har höjt förstapriset i C.L. Müllers Memorial till 600.000 kronor i år. Förhoppningsvis blir det ett lopp som förgyller dagen, säger sportchef Mats Ahlqvist.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/08/propositioneroktober2025.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/08/propositioneroktober2025.pdf" target="_blank" rel="noreferrer noopener">Propositionshäftet för oktober kan laddas ner här.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4 De blågula inslagen på fransk mark fortsätter och idag startar Jörgen S Eriksson <strong>Loyal Eleven</strong> (e. Fastissime) i Prix Arum (€20.000) över 2.875 meter i <strong>Meslay-du-Maine</strong> (första start kl. 12.34). Den fyraårige valacken har inlett med tre raka andraplatser på fransk mark – kan Eric Raffin ändra på den detaljen?</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/raffinerichappy210508adamstromstalltz-617x411.jpg" alt="" class="wp-image-160582"/><figcaption class="wp-element-caption">Eric Raffin. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Mer svenskt blir det i ett lopp öppet för europafödda travare. Jimmy Dahlman tar ut <strong>Global Attention</strong> (e. Love You) i Prix de la Ville de Meslay-du-Maine (€30.000) över 2.875 meter med Paul-Philippe Ploquin i sulkyn. Där startar också svenskfödde <strong>Dynamite Sensation</strong> (e. Orlando Vici).</p>



<p class="wp-block-paragraph">Senare på kvällen i <strong>Cabourg </strong>(första start kl 19.30) plockar Rikard Björling ut <strong>Istra </strong>(e. Ulysse) och det sjuåriga stoet är på jakt efter första årssegern i Prix de Bive (€26.000) över 2.750 meter med Alexis Collette i sulkyn.</p>



<p class="wp-block-paragraph">I ett Grupp III-lopp i <strong>Grenade-sur-Garonne</strong> (första start kl. 10.30) – Grand Prix Dynavena (€51.000) – står <strong>Donzetti</strong> (e. Maharajah) start, distansen är 2.700 meter och förstapriset uppgår till 22.950 euro.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 Grupp I-löpningen Gran Premio di Citta Montcatini (€120.000) avgörs ikväll i Montecatini med försök och final över sprinterdistans. De svenska hästar lyser med sin frånvaro och som vanligt har Alessandro Gocciadoro det förspänt på papperet med tre hästar – <strong>Click Bait</strong>, <strong>Bengurion Jet </strong>och <strong>Banderas Bi </strong>– till start i det första försöket.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/alessandrogocciadoro-617x333.jpg" alt="" class="wp-image-604183"/><figcaption class="wp-element-caption">Alessandro Gocciadoro har sex hästar till start. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Lika många hästar selas ut från Gocciadoro-stallet i det andra försöket: <strong>Bepi Bi</strong>, <strong>Cointreau </strong>och <strong>Dany Capar</strong>.</p>



<p class="wp-block-paragraph">De fyra första plus den snabbaste femman får plats i finalen.</p>



<p class="wp-block-paragraph"><strong>Gran Premio di Citta Montcatini</strong> (€10.010) <strong>– försök I:</strong><br>Äldre hästar.<br><em>1.640 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Ector Francis </strong>(e. Nad al Sheba) – Gaetano di Nardo</li>



<li><strong>Emma dei Veltri </strong>(e. Maharajah) – Antonio di Nardo</li>



<li><strong>Click Bait </strong>(e. Cantab Hall) – Gabriele Gelormini</li>



<li><strong>Dakovo Mail </strong>(e. Nad al Sheba) – Giampaolo Minnucci</li>



<li><strong>Extra Model</strong> (e. Ruty Grif) – Roberto Vecchione</li>



<li><strong>Bengurion Jet </strong>(e. Maharajah) – Manuel Pistone</li>



<li><strong>Banderas Bi</strong> (e. Ganymede) – Alessandro Gocciadoro</li>



<li><strong>Ernesto Spritz</strong> (e. Maharajah) – Andrea Farolfi</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Massimiliano Castaldo</li>
</ol>



<p class="wp-block-paragraph"><strong>Försök II:</strong></p>



<ol class="wp-block-list">
<li><strong>Eclissi de Re Dr</strong> (e. Wishing Stone) – Francesco di Stefano</li>



<li><strong>Due Italia </strong>(e. Adrian Chip) – Marco Stefani</li>



<li><strong>Zefiro d’Ete</strong> (e. Mago d’Amore) – Gaetano di Nardo</li>



<li><strong>Vincero Gar</strong> (e. S.J.’s Photo) – Antonio di Nardo</li>



<li><strong>Bepi Bi</strong> (e. Donato Hanover) – Giampaolo Minnucci</li>



<li><strong>Caronte Trebi</strong> (e. Nad al Sheba) – Carmine Piscuoglio</li>



<li><strong>Bleff Dipa</strong> (e. Mister J.P.) – Roberto Vecchione</li>



<li><strong>Cointreau </strong>(e. Nad al Sheba) – Federico Esposito</li>



<li><strong>Dany Capar </strong>(e. Exploit Caf) – Alessandro Gocciadoro</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/12/henriksenperstalltzsm-617x370.jpg" alt="" class="wp-image-16131"/><figcaption class="wp-element-caption">Per Henriksen. Foto: Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Igår kunde Sulkysport berätta att Sveriges äldste proffstränare – <a href="https://sulkysport.se/foppa-slutar-som-tranare/" data-type="link" data-id="https://sulkysport.se/foppa-slutar-som-tranare/" target="_blank" rel="noreferrer noopener">Lennart Forsberg</a> – lämnar in sin A-licens den 31 augusiti. Per Henriksen blir då åldermannen i proffsskrået i Sverige med 79 år och han följs av Gunnar Melander (78 år) och Mats Rålund (75 år).</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 I onsdags somnade Sven Österblom in efter en tids sjukdom och den tidigare Solvallatränaren blev 79 år. Han var som hetast under 1970-talet och firade en hel del framgångar både i Sverige och utomlands.</p>



<p class="wp-block-paragraph">Den danske Derbytvåan <strong>Calpam</strong> – ägd av Stall Piccolino – tävlade huvuddelen av sin karriär hos Sven Österblom och bland segrarna ska också Harper Hanovers lopp nämnas även om löpningen inte hade samma dignitet då som idag.</p>



<p class="wp-block-paragraph">Calpam vann 16 lopp som tre- och fyraåring och var en av de bästa sönerna till <strong>Frosty Hanover</strong>, som tog fem hingstchampionat i Danmark. Även om inte Calpam vann Derbyt så lämnade han en son – <strong>Frej Nalan</strong> – som tog hem det ”blå bandet” i Sverige 1989.</p>



<p class="wp-block-paragraph">En annan stjärna var högkapable <strong>Speedy Herman</strong>, vilken segrade både i Svenskt Trav S:t Leger och Nordiskt 4-åringspris. S:t Leger vann också <strong>Papageno</strong> och precis som Speedy Herman var han en son till Speedy Spin.</p>



<p class="wp-block-paragraph">Sven Österblom lade ner sin träningsrörelse 2001 och fortsatte som hovslagare.</p>

Fokustema
Läs senare
Vem vinner Hot’n Cold?
Devalverad prissumma i kall- och varmblodsmatch. Müllers med högre förstapris. Senareläggning av första start på V85-lördagar. Sven Österblom ur tiden.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
