
<p class="has-drop-cap wp-block-paragraph">1 I fredags tog Ann-Catrin Frisk-tränade <strong>Cool Trix</strong> (e. Trixton) och Ove A Lindqvist hem Varma Hästägarekannan på Umåker efter en rejäl insats. Ikväll kan Cool Trix plocka hem ytterligare en hästägarekanna – i <strong>Boden</strong> (första start 18.20).</p>



<p class="wp-block-paragraph">15 hästar på fyra volter över lång distans gör upp i varmblodens kanna, där Cool Trix har sällskap på volten längst bak av <strong>B.Sacamano </strong>(e. Prodigious) och isbanespecialisten <strong>Humble Stance</strong> (e. Repeat Love). Den sistnämnde har inte tävlat sedan i januari.</p>



<p class="wp-block-paragraph">50.000 kronor väntar vinnaren, precis som i kallblodens avdelning. Även den med 15 hästar, som däremot är utspridda på hela sex volter över medeldistans. 100 meters tillägg är uppgiften för Mats Gällerstedt-tränade <strong>Källsjöviking</strong> (e. Järvsöviking) tillsammans med Ove A Lindqvist.</p>



<p class="wp-block-paragraph">Hästen har testat många tillägg tidigare. Som i senaste starten i Skellefteå för drygt två veckor sedan där han startade från 80 meters tillägg och slogs om segern, men fick ge sig i sista stegen mot <strong>Älvsnabben M.R.</strong> (e. Järvsöviking).</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Norske amatören Tor Örjan Johansen reste till Sverige med toppstoet <strong>Åsrud Vilja</strong> (e. Järvsöviking), 1.20,0ak/3.911.771 kr, under pandemin 2020 och firade stora framgångar. Då stallade han upp hästen hos Bollnästränaren Peter Eriksson. Nästa år ser det ut att bli en permanent flytt till Sverige.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/asrudviljamfol-617x333.jpeg" alt="" class="wp-image-585405"/><figcaption class="wp-element-caption">Norska stjärnstoet Åsrud Vilja har fått ett hingstföl med Tekno Odin som far. Tor Örjan Johansen är mannen bakom stoet som importerats till Sverige. Foto Privat</figcaption></figure>



<p class="wp-block-paragraph">– Ja, jag har funderat på det ett tag. När pandemin kom 2020 flydde jag Norge under en period. Sedan etablerade jag en slags filial hos Eriksson, som jag har haft ett bra samarbete med sedan dess. Det är den filialen jag har öppnat igen nu, har Tor Örjan berättat för Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Åsrud Vilja ägs fortsatt av Johansen och finns redan i Sverige. Hon har fått två svenskregistrerade hingstföl med Tekno Odin som pappa, där ettårige <strong>Åsrud Odin</strong> är äldst. Åsrud Vilja är nu dräktig me Ängsborken.</p>



<p class="wp-block-paragraph">Idag på lunchbanan <strong>Gävle</strong> (första start 12.20) dyker Åsruds Viljas lillebror <strong>Åsrud Jerven</strong> (e. Fjord Jerven) upp. Det är enda starthästen i Johansens stall och precis som storasyster en minst sagt segervan sådan. Sjuårige Åsrud Jerven inledde tävlingskarriären först som sexåring och har tagit 14 segrar på 30 starter sedan dess. På svensk mark har hästen vunnit tio av elva starter!</p>



<p class="wp-block-paragraph">Bland motståndarna idag finns Oskar Kylin Bloms formstarke femåring <strong>Friska Viljan </strong>(e. Järvsö Björn), som vann två lopp i oktober. Friska Viljan var finalist i både svenska och norska Derbyt förra året.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/12/251218.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/12/251218.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>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/10/adolfssonsofiasmmedaljerp171014adamstromstalltz-617x583.jpg" alt="" class="wp-image-13867"/><figcaption class="wp-element-caption">Sofia Adolfsson är segerrikaste ryttare i år i Sverige. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3 Efter fyra år i topp petas Jonathan Carré ned från den svenska montétronen. När Sofia Adolfsson i en tät duell med just Carre vann montéloppet på Jägersro i tisdags med <strong>Västerbo Imtheman </strong>(e. Echo) före Carrés ritt Yuvaraj (e. Maharajah).</p>



<p class="wp-block-paragraph">– Det har blivit en liten grej det här och folk som engagerar sig och det är kul. Det är några sedan jag var i den positionen, men det är ett kvitto på att jag har haft ett bra år, sade Sofia Adolfsson efteråt.</p>



<p class="wp-block-paragraph">Det är fjärde gången Adolfsson blir montéchampion i Sverige, 2016, 2017 och 2018 lade hon också beslag på titeln.</p>



<p class="wp-block-paragraph">Rekordåret i sadeln var 2018 när Sofia vann hela 61 lopp och red in över tre miljoner kronor. Den detroniserade championryttaren Jonathan Carreé slog de siffrorna 2022 med 66 segrar och över fyra miljoner kronor inridet.</p>



<p class="wp-block-paragraph">Återstående montélopp i Sverige 2025: <strong>Färjestad</strong> (19 december),<strong> Kalmar</strong> (19 december), <strong>Bollnäs </strong>(21 december) och <strong>Romme</strong> (29 december).</p>



<h2 class="wp-block-heading">Tio-i-topp montéryttare 2025 – Sverige</h2>



<p class="wp-block-paragraph"><strong>Ryttare, hemmabana – Resultat – Inkört</strong></p>



<ol class="wp-block-list">
<li>Sofia Adolfsson, Örebro – 86 st: 32-15-8 – 1.972.100 kr</li>



<li>Jonathan Carre, Åby – 120 st: 28-21-20 – 2.561.400 kr</li>



<li>Saga Laursen, Axevalla – 102 st: 17-11-19 – 1.436.700 kr</li>



<li>Tova Bengtsson, Åby – 43 st: 11-9-6 – 898.500 kr</li>



<li>Iina Aho, Axevalla – 77 st: 10-15-12 – 1.094.600 kr</li>



<li>Julia Andersson, Mantorp – 70 st: 10-10-5 – 937.200 kr</li>



<li>Agnes Larsson, Solvalla – 50 st: 10-7-7 – 743.200 kr</li>



<li>Emilia Leo, Axevalla – 41 st: 9-6-5 – 1.090.500 kr</li>



<li>Malin Andersson, Åby – 66 st: 7-5-10 – 623.200 kr</li>



<li>Jonna Jakobsson, Halmstad – 51 st: 6-6-4 – 391.500 kr</li>
</ol>



<p class="wp-block-paragraph"><strong>Fotnot:</strong> statistiken gäller starter på svenska banor.</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Det börjar närma sig Prix de Cornulier (€700.000) och det märks inte minst i lördagens sadellopp på Vincennes. Där är Olle Alséns <strong>Joy Alissa </strong>(e. Maharajah) ute på väldigt djupt vatten i semi-classique-löpningen Prix Jules Lemonnier (€120.000) över 2.175 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/sartilly3-617x367.jpg" alt="" class="wp-image-677325"/><figcaption class="wp-element-caption">Joy Alissa vid seger på Vincennes under sadel. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Ettan, tvåan, trean och fyran från Prix Paul Buquet (€120.000) finns med i loppet och där besegrade <strong>Je M’Envole </strong>(e. Joyau d’Amour), <strong>Ideale du Chene </strong>(e. Bird Parker), <strong>Jean Balthazar </strong>(e. Alto de Viette) och <strong>Fulton</strong> (e. Royal Dream).</p>



<p class="wp-block-paragraph">Mot dessa kraftpaket ställs Joy Alissa och nämnas ska också formtoppade dansken <strong>Eros Zola</strong> (e. Zola Boko), som tog hem Prix de l’Ile d’Oleron (€75.000) senast den nioårige valacken var ute under sadel.</p>



<p class="wp-block-paragraph"><strong>Prix Jules Lemonnier </strong>(€120.000)<br>5-10 år.<br><em>2.175 meter, monté.</em></p>



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



<ol class="wp-block-list">
<li><strong>Joy Alissa</strong> (e. Maharajah) – Estelle Croisic</li>



<li><strong>Illusion Jipad </strong>(e. Boccador de Simm) – Guillaume Lenain</li>



<li><strong>Je M’Envole</strong> (e. Joyau d’Amour) – Mathieu Mottier</li>



<li><strong>Eros Zola</strong> (e. Zola Boko) – Alexandre Abrivard</li>



<li><strong>Fulton</strong> (e. Royal Dream) – Damien Bonne</li>



<li><strong>Jean Balthazar</strong> (e. Alto de Viette) – Guillaume Martin</li>



<li><strong>Ina du Rib</strong> (e. Uhlan du Val) – Jean-Loïc Claude Dersoir</li>



<li><strong>Hirondelle du Rib</strong> (e. Rolling d’Heripre) – Noé Perron</li>



<li><strong>Ideale du Chene</strong> (e. Bird Parker) – Paul-Philippe Ploquin</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/2024/07/alessandrogocciadoro-617x333.jpg" alt="" class="wp-image-604183"/><figcaption class="wp-element-caption">Alessandro Gocciadoro är segerrikast av alla tränare i Europa i år. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5 Året börjar närma sig sitt slut och <strong>Alessandro Gocciadoro </strong>har haft ett starkt år som vanligt och till dags dato står han på 371 tränarsegrar i Europa och det kan ingen annan matcha. Johan Untersteiner är tvåa med 272 segrar och därefter följer Gennaro Casillo med 269 vinster. Fyra är Thierry Duvaldestin med 225 triumfer.</p>



<p class="wp-block-paragraph">I Nordamerika är tre tränare vassare än Gocciadoro; Ron Burke toppar med 1.101 vinster före Per Engblom med 417 och Jeff Cullipher med 345 segrar.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Spårlottningen till finalen i MGM Grand Prix ($250.000) på Yonkers Raceway på fredag natt svensk tid är klar. Två svenskfödda travare – <strong>Antognini </strong>(e. Father Patrick) och <strong>Ultion Face</strong> (e. Joke Face) – har kvalat in till finalen över 2.011 meter, varav den sistnämnde tränas av Per Engblom. Ytterligare en häst – <strong>Cecil Hanover</strong> (e. Chapter Seven) – selas ut från Engbloms stall i finalen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/wb012525r5antognonis-617x346.jpg" alt="" class="wp-image-681715"/><figcaption class="wp-element-caption">Ron Burkes segermaskin Antognoni. Foto: Lisa Photo</figcaption></figure>



<p class="wp-block-paragraph"><strong>Sir Pinocchio</strong> (e. Met’s Hall) har vunnit samtliga tre försök han startat i och dessutom varit snabbast med tiden 1.10,6/1.609 meter. Två försöksvinster har <strong>Antognini</strong> och Take All Comers (e. Creatine), medan <strong>Ari Ferrari J</strong> (e. Walner) och <strong>Dribbling Bi</strong> (e. Cantab Hall) vunnit ett vardera.</p>



<p class="wp-block-paragraph"><strong>MGM Grand Prix</strong> ($250.000)<br>Treåriga &#038; äldre travare.<br><em>2.011 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Ari Ferrari J</strong> (e. Walner) – Jim Marohn Jr.</li>



<li><strong>Antognoni</strong> (e. Father Patrick) – Yannick Gingras</li>



<li><strong>Sir Pinocchio</strong> (e. Met’s Hall) – Jason Bartlett</li>



<li><strong>Blackhawl Zette</strong> (e. Cantab Hall) – Brent Holland</li>



<li><strong>Ultion Face</strong> (e. Joke Face) – Tyler Buter</li>



<li><strong>Asteroid </strong>(e. Creatine) – Colin Kelly</li>



<li><strong>Southwind Coors</strong> (e. Walner) – George Brennan</li>



<li><strong>Cecil Hanover </strong>(e. Chapter Seven) – Brett Beckwith</li>



<li><strong>Take All Comers</strong> (e. Creatine) – Todd McCarthy</li>



<li><strong>Dribbling Bi</strong> (e. Cantab Hall) – Daniel Dube</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 Pierre Pilarskis färger är inte lika vanligt förekommande på den franska huvudstadsovalen sedan Bold Eagle härjade på Vincennes och bland annat tog hem dubbla Prix d’Amérique. Nu kan en ny stjärna vara på väg att tändas.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/12/skarmavbild20251217kl.17.57.32.png" alt="" class="wp-image-804438"/><figcaption class="wp-element-caption">Notable vinner för Eric Raffin.</figcaption></figure>



<p class="wp-block-paragraph">Igår på Vincennes tog tvåårige <strong>Notable</strong> (e. Niky-Alizea du Kastel) sin tredje raka seger efter ha blivit diskad i debuten. Eric Raffin satt i sulkyn bakom den Sébastien Guarato-tränade hingsten. Varvet före mål gick Notable med i rygg i tredjespår som trea, men 900 kvar vred Eric Raffin på i fjärdespår (!) och forcerade tvååringen till täten 250 meter senare.</p>



<p class="wp-block-paragraph">Upploppet ned handlade det bara om Notable och han behövde inte bruka några reservkrafter för att ta hem Prix des Iris (€38.000) på nya rekordet 1.15,1/2.100 meter.</p>



<p class="wp-block-paragraph">– Jag tycker att Notable har något extra. Han är min bästa tvåårige hingst, sade tränaren Sébastien Guarato efter segern.</p>



<p class="wp-block-paragraph">Notable var ute på Arqana Trot-auktionen i Deauville som ettåring, men sonen till Niky och <strong>Alizea du Kastel </strong>(e. Quaker Jet), 1.11,5/€229.440, togs tillbaka för 40.000 euro. Modern tävlade framgångsrikt som unghäst, vann Prix Marcel Dejean (€80.000) som tvååring och året efter tog hon hem Prix Roquepine (€120.000).</p>



<p class="wp-block-paragraph">Notable är tredje avkomman och Alizea du Kastel har också lämnat <strong>Le Conquerant</strong> (e. Ready Cash), 1.14,6/€28.475. Mormor <strong>Kalida Jet </strong>(e. Extreme Dream), 1.14,6/€90.078, har också lämnat <strong>Rebecca Jet</strong> (e. Defi d’Aunou), 1.12,2/€275.650.</p>
