
<p class="has-drop-cap wp-block-paragraph">1 Srf Stables dollarmiljonär <strong>Oh Well</strong> (e. Muscle Hill-Fine Tuned Lady), 1.08,6/$1.566.877, lägger tävlingsskorna på hyllan efter 39 starter (8-13-3) och ska stallas upp som avelshingst nästa år.</p>



<p class="wp-block-paragraph">Marcus Melander tränade Oh Well under hela hans karriär och största segern togs i Mohawk Million ($1.000.000) på Mohawk Raceway, men han finalvann också New Jersey Classic ($275.000) och New Jersey Sire Stakes ($240.000) på Meadowlands under sitt första tävlingsår.</p>



<p class="wp-block-paragraph">Under treåringssäsongen segrade han bland annat i en division av Stanley Dancer Memorial ($138.500) och Bluegrass Series ($78.000). Dessutom slutade han tvåa i Hambletonian Stakes – slagen med en längd av <strong>Tactical Approach</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/lennartagren-617x333.jpg" alt="" class="wp-image-639268"/><figcaption class="wp-element-caption">Lennart Ågren. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Lennart ”Srf Stable” Ågren betalade 530.000 dollar för Oh Well i Harrisburg som ettåring och han är moderns första avkomma. <strong>Fine Tuned Lady</strong> (e. Cantab Hall) tog vinnarrekordet 1.09,8 och sprang in 643.987 dollar. Sina största triumfer räknade hon in som tvååring i finalen i Pennsylvania Sire Stakes ($252.000) och Kentuckiana Stallion Management ($250.000).</p>



<p class="wp-block-paragraph">Mor är hon också till Muscle Hill-duon <strong>My Way</strong>, 1.10,6/$76.500, och <strong>C Me B Me</strong>, 1.08,9*/$36.800. Fine Tuned Lady ingår i sin tur i samma syskonskara som <strong>Everyones Talkin</strong> ($501.585), <strong>Poster Pin Up</strong> ($439.135), <strong>Call To Post </strong>($416.519) och <strong>Prince Rocco</strong> ($167.921).</p>



<p class="wp-block-paragraph">Oh Well kommer verka som avelshingst på Premier Acres i Middlebury i staten Indiana och avgiften blir 4.000 dollar.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Ett koppel vassa, unga kallblod dyker upp på torsdagens huvudbana <strong>Gävle </strong>(första start 18.20) ikväll främst treåringsloppet Jöns Olofssons Minne och Leufstaloppet för fyraåringar avgörs.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/gorsomjagvillrs-617x333.jpg" alt="" class="wp-image-750766"/><figcaption class="wp-element-caption">2024 års Kriterievinnare Gör Som Jag Vill och Robert Skoglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Bergsåkertränaren Robert Skoglund har ett starkt kort i båda loppen. Fyraårige <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) vann Kriteriet på Dannero förra året och har i år kvalat in till både svenska och norska Derbyt i år, där han slutat femma och sexa. Däremot står det fortfarande en nolla i årets segerkolumn och kanske kan han spräcka den ikväll, även om tufft motstånd kommer från främst formstarka <strong>Trollbackens Olov</strong> (e. Odin Tabac) och <strong>Holms Oden</strong> (e. Bork Odin). Dubbla tillägg över sprinterdistans är uppgiften för Gör Som Jag Vill och Trollbackens Olov.</p>



<p class="wp-block-paragraph">I treåringsloppet är förutsättningarna desamma för Skoglunds <strong>Ängsrask</strong>, men motståndarna är färre och uppgiften ser bra ut för treåringen som sprungit in nästan 600.000 kronor i år efter andraplats i svenska Kriteriet och tredjeplats i den norska upplagan.</p>



<p class="wp-block-paragraph">I ett stolopp för tre- och fyraåriga kallblod plockar Sandra Eriksson ut årets enda klassiska, svenskfödda vinnare på kallblodssidan. <strong>Tekla</strong> (e. Tekno Odin) slog nämligen till i norska Stokriteriet, där hon vann överlägset med tränaren i vagnen. Nu lämnar Sandra över tömmarna till Mika Forss, som kört två gånger tidigare och vunnit båda.</p>



<p class="wp-block-paragraph"><strong>Så här gick i kallblodens klassiker 2025:</strong></p>



<ul class="wp-block-list">
<li>Kriteriet Sverige: <strong>Grude Nils</strong> (e. Grisle Odin) – Kjetil Djöseland, Norge</li>



<li>Kriteriet Norge: <strong>Grude Nils</strong> (e. Grisle Odin G.L) – Kjetil Djöseland, Norge</li>



<li>Kriteriestoet Sverige: <strong>Kleppe Nissemor</strong> (e. Norheim Svenn) – Jan Roar Mjölneröd, Norge</li>



<li>Stokriteriet Norge: <strong>Tekla</strong> (e. Tekno Odin) – Sandra Eriksson, Boden</li>



<li>Derbyt Sverige: <strong>Tangen Martin</strong> (e. Bork Odin) – Öystein Tjomsland, Norge</li>



<li>Derbyt Norge: <strong>Gigant Tide</strong>r (e. Norheim Svenn) – Kjetil Djöseland, Norge</li>



<li>Derbystoet Sverige: <strong>Hå Lerke</strong> (e. Nordsjö Odin) – Öystein Tjomsland, Norge</li>



<li>Stoderbyt Norge: <strong>Årdals Fröya</strong> (e. Norheim Svenn) – Frode Hatlevik, Norge</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">3 Sprinterlopp för rutinerade varmblod finns det gott om runt om i landet, men kvällens snabblopp i Gävle är lite speciellt även om det bara är sex hästar i startlistan. Vallonloppet avgörs nämligen med voltstart!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/darkroadster-617x333.jpg" alt="" class="wp-image-392745"/><figcaption class="wp-element-caption">Världsrekordtravaren Dark Roadster. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Färsk erfarenhet i voltstart är det inte speciellt gott om bland hästarna som tjänat nästan 20 miljoner kronor tillsammans hittills, men bland de sex finns en världsrekordtravare över just sprinterdistans med voltstart. <strong>Dark Roadster</strong> (e. Super Photo Kosmos) tangerade nämligen världsrekordet när han segrade på Solvalla på 1.11,1/1.660 meter för nästan exakt två år sedan.</p>



<p class="wp-block-paragraph">På varmblodssidan bjuder Gävle också finalen i Maharajahs stoserie med 100.000 kronor till vinnaren. 15 hästar i en spårtrappa över medeldistans gör upp om prischecken och Markus Pihlström har ett vasst kort i <strong>A Last Chance</strong> (e. Royalty For Life), som vunnit fem lopp i år.</p>



<p class="wp-block-paragraph">Dessa varmblodslopp och fyra kallblodslopp utgör kvällens V64-kupong, där det är jackpot och över 1,6 miljoner kronor extra i sexrättspotten.</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Hans Ahlbins supertalang <strong>Tangens </strong>(född 1981 e. Lep Hanover), 1.15,1ak*/782.310 kr, vann totalt 21 av 36 starter i karriären. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/03/tangens-617x357.jpg" alt="" class="wp-image-143089"/><figcaption class="wp-element-caption">Tangens och Hans Ahlbin. Foto Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Som tvååring tog Tangens 16 segrar på lika många starter, han satte två svenska rekord, vann Svensk Uppfödningslöpning och åkte sedan till Rom och vann Italiens största tvååringslopp Gran Premio Allevatori, vilket då var öppet för utlandsfödda travare, med Stig H Johansson i sulkyn.</p>



<p class="wp-block-paragraph">Sju av starterna som tvååring gjordes på Visbytravet, där han bland annat satte ett av sina två svenska rekord.</p>



<p class="wp-block-paragraph">Numera är tvååringstävlandet på ”ön” ytterst begränsat. 2019 kördes inte ens något tvååringslopp i Visby. Sedan 2020 har det varit ett lopp om året och så gäller även i år. Idag när <strong>Visby</strong> (första start 12.20) har lunchtävlingar är det dags för årets lopp. Blott tre hästar sluter upp i kamp om 30.000 kronor i förstapris sedan <strong>Floki</strong> (e. Victor Gio) strukits. </p>



<p class="wp-block-paragraph">Till <strong>Örebros </strong>(start 17.45) breddplus-tävlingar ikväll var anmälningsintresset stort. Delningspropositionen upp till 2,5 miljoner mynnade ut i åtta lopp (139 hästar anmäldes!) och dessutom delades den lägre ”proppen” upp till 30.000 kronor i två.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">5 Idag med start klockan 10.00 och fram till 17.00 visas ettåringarna som bjuds ut till försäljning på <strong>Criterium Sale</strong> på Solvallas stallbacke. Auktionen hålls imorgon på Kongressen och första utrop är klockan 17.00.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/laddar-med-117-ettaringar/" data-type="link" data-id="https://sulkysport.se/laddar-med-117-ettaringar/" target="_blank" rel="noreferrer noopener">Läs mer om auktionen här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6 Jarmo Niskanen-tränade <strong>Katitzi</strong> (e. Earl Simon) jagar sin andra raka triumf i lärlingsloppet Prix du Donezan (€19.000) i <strong>Lyon </strong>(första start kl 11.51) idag. Precis som vid förra triumfen i Prix d’Evreux Portes de Normandie (€14.500) i Evreux sitter Joan Melis Macias i sulkyn. Distansen är 2.000 meter och förstapriset 8.550 euro.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/03/iznogoudam2-617x333.jpg" alt="" class="wp-image-280953"/><figcaption class="wp-element-caption">Iznogoud Am. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Till Lyon åker också Sabine Kagebrant med <strong>Iznogoud Am </strong>(e. Muscle Hill) och den svenskfödde valacken går ut Prix du Forez (€39.000) och körs av Pierre Vercruysse. </p>



<p class="wp-block-paragraph">I samma lopp startar också Magnus Jernemyr-ägde <strong>Champ Lane </strong>(e. Bold Eagle) och <strong>Silver Bullit </strong>(e. Orlando Vici). De två sistnämnda står 25 meter före Iznogoud Am – grunddistansen är 2.850 meter – och det tävlas om ett förstapris på 17.550 euro.</p>



<p class="wp-block-paragraph"> Mer svenskt blir det senare i eftermiddag på <strong>Enghien </strong>(kl. 16.19) och Marie Norberg sitter upp bakom egentränade <strong>Lady d’Elfe</strong> (e. Bon Copain) i Prix de Pradelles (€40.000) över 2.875 meter. Senare under dagen startar och kör Norberg också <strong>Justess Viking </strong>(e. Ubriaco) i Prix de Sevran (€41.000) över 2.150 meter med autostart.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/leroybokohladam-617x333.jpg" alt="" class="wp-image-632214"/><figcaption class="wp-element-caption">Leroy Boko och Hanna Lähdekorpi vid segern i K.G.Bertmarks Minne på Jägersro. Idag är det sadel som gäller för Conrad Lugauers häst. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">I sadelloppet Prix de la Place du Canada (€43.000) startar hela sex svenskfödda travare; <strong>Rustico </strong>(e. Classic Photo), <strong>Blauer Max</strong> (e. Orlando Vici), <strong>King Chaos</strong> (e. Red Hot Dynamite), <strong>Hawker Typoon</strong> (e. Maharajah), <strong>Make It A Star</strong> (e. Make It Happen) och <strong>Leroy Boko </strong>(e. Trixton). De två sistnämnda tränas av Fredrik Wallin respektive Conrad Lugauer.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 För er som är intresserad av kapplöpningar och dess historia och då speciellt Normandie och Paris så har Philippe Lucas i dagarna givit ut boken ”Des histoires d’hippodromes”.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/skarmavbild20251008kl.09.21.56-617x456.jpg" alt="" class="wp-image-777456"/><figcaption class="wp-element-caption">Förstasidan från Philippe Lucas bok.</figcaption></figure>



<p class="wp-block-paragraph">Sedan liten grabb har Philippe Lucas fascinerats av kapplöpningsbanor och med tidens tand har han samlat på sig en exceptionell samling av mer än 1.200 kapplöpningsvykort.</p>



<p class="wp-block-paragraph"><a href="https://www.lavauzelle.com/equitation/equitation/1353-des-histoires-d-hippodromes-de-la-normandie-aux-hippodromes-parisiens-9782702517291.html" data-type="link" data-id="https://www.lavauzelle.com/equitation/equitation/1353-des-histoires-d-hippodromes-de-la-normandie-aux-hippodromes-parisiens-9782702517291.html" target="_blank" rel="noreferrer noopener">Boken ges ut på Lavauzelle équitation.</a></p>
