
<p class="has-drop-cap wp-block-paragraph">1En finalist i Svenskt Travkriterium för en dryg månad sedan finns med i startlistorna när det blir Kriterie- och Oaksrevanscher på Solvalla (första start 18.15) ikväll med 200.000 kronor till vinnaren i varje klass.</p>



<p class="wp-block-paragraph">Det handlar om David Persson-tränade <strong>Toto Tooma</strong> (e. Explosive Matter), som glänste stort vid segern i uttagningsloppet efter en rejäl slutspurt. I finalen blev det en femteplats, innan han slutade oplacerad i BC-semifinalen från svårt läge. Han var även fyra i korta E3 i somras.<br>– Han är för dagen nog är mer stark än snabb, men det är en sådan häst som kommer att gå väldigt bra över kort distans med när väl den dagen kommer. Han öppnar ju till exempel inte så snabbt fortfarande, men jag tror att han kan bli en riktig katapult från start när det väl släpper till i huvudet på honom. Han springer och tvekar lite bakom bilen fortfarande och det kommer han att göra även nu. Hästen kommer inte ta sig i väg bra, så det är bra med det här läget som vi fick. Jag vet att vi möter dugliga konkurrenter nu, men vi har en häst som är stark och rejäl, han gillar distansen, säger tränaren David Persson till Kanal75.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/icyconditionscsm260422adamstromstalltz-617x419.jpg" alt="" class="wp-image-841593"/><figcaption class="wp-element-caption">Icy Conditions och Claes Sjöström vid segern i Vårfavoriten i april. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">I Oaksrevanschen gör Claes Sjöströms vinterstjärna <strong>Icy Conditions</strong> (e. Calgary Games) tredje starten efter halvårslångt uppehåll. Andraplatsen i Sikta Mot Stjärnornas final i comebacken följdes av en ”nolla” i BC-semifinalen efter tung resa i dödens.<br>Bland kvällens motståndare finns Mattias Djuses nästanmiljonärska och dubbla E3-femma <strong>Fusion Blaze</strong> (e. Southwind Frank), samt Daniel Redéns uppstickare <strong>Mellby Ossa</strong> (e. Readly Express).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/11/18v86.pdf" target="_blank" rel="noopener">Här är startlistorna till Solvallas tävlingar med V86.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2Eirik Höitomt har vunnit norska körsvensligan 16 gånger, flest av alla norska kuskar i historien. Ulf Thorsen och Gunnar Eggen tog titeln 13 gånger vardera. I år stormar Höitomt fram mot en ny titel och leder med över 60 vinster före Åsbjörn Tengsareid.</p>



<p class="wp-block-paragraph">På kvällens andra V86-bana Bjerke (första start 18.27) sitter Höitomt också säkert på tronen med 45 segrar under 2026. Däremot slår han ur underläge i kvällens V86-lopp. Han kör i samtliga, men segerchanserna är små på förhand.</p>



<p class="wp-block-paragraph">Hästen som sticker ut på Bjerke är kristian Malmin-tränade <strong>Urban Tile</strong> (e. Face Time Bourbon). Den svenskfödde fyraåringen imponerade när han tog ned <strong>Sauron Zon</strong> (e. Six Pack) i klass III-försöket på Bjerke för 2,5 veckor sedan och den toppstammade travaren har vunnit fem av åtta starter i år.</p>



<p class="wp-block-paragraph"><strong>Kuskligan Bjerke 2026</strong><br><em>Kusk, hemmabana – Resultat – Segerprocent</em></p>



<ol class="wp-block-list">
<li>Eirik Höitomt, Jarlsberg – 286 st: 45-32-38 – 15,7%</li>



<li>Åsbjörn Tengsareid, Jarlsberg – 267 st: 31-27-20 – 11,6%</li>



<li>Magnus Teien Gundersen, Bjerke – 208 st: 30-30-20 – 14,4%</li>



<li>Vidar Hop, Jarlsberg – 177 st: 30-25-15 – 16,9%</li>



<li>Lars Anvar Kolle, Jarlsberg – 205 st: 24-31-19 – 11,7%</li>



<li>Kristian Malmin, Bjerke – 105 st: 24-17-7 – 22,9%</li>



<li>Erlend Rennesvik, Bjerke – 165 st: 18-20-27 – 10,9%</li>



<li>Frode Hamre, Jarlsberg – 84 st: 18-19-9 – 21,4%</li>



<li>Gunnar Austevoll, Momarken – 153 st: 14-17-13 – 9,2%</li>



<li>Tom Erik Solberg, Klosterskogen – 137 st: 14-13-14 – 10,2%</li>
</ol>



<p class="wp-block-paragraph"><strong>Källa: </strong>travsport.no</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/2026/05/oscarberglund-617x333.jpg" alt="" class="wp-image-856753"/><figcaption class="wp-element-caption">Oscar Berglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Östersund (första start 12.20) bjuder på en fullmatad lunch med välfyllda lopp och en hel del stora fält. Hemmatränaren Oscar Berglunds stallform har varit upp och ned, men siffrorna är bättre än de senaste säsongernas både vad gäller segrar, inkört och segerprocent. 33 vinster på 105 starter – 31 i segerprocent! – har det blivit hittills under 2026.</p>



<p class="wp-block-paragraph"><strong>S.G.Mistral</strong> (e. Charly du Noyer) kom till Berglund i december förra året och har åtta segrar på 13 starter efter flytten norrut. Nu kommer han ut från tillägg i ett dubbelklasslopp med flera rikstotobekantingar bland motståndarna.</p>



<p class="wp-block-paragraph">Bland Berglund framtidskapital finns treåriga stoet <strong>Clover Club</strong> (e. Readly Express), som imponerade stort när hon rekordsänkte med över tre sekunder till 1.14,0am vid karriärens första seger. Då travade hon i ledningen, medan hon idag inleder i andra ledet bakom bilen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/11/261118.pdf" target="_blank" rel="noopener">Här är startlistorna till onsdagens tävlingar. </a></p>



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



<p class="has-drop-cap wp-block-paragraph">4David Persson, Maria Törnqvist och Daniel Wäjersten har varsin starthäst i franska Mauquency idag – och deras hästar dyker upp i olika lopp på banan i Normandie. Dessutom har Marie Norberg en franskfödd duo till start.</p>



<p class="wp-block-paragraph">Törnqvist-tränade <strong>Patton</strong> (e. Trixton) var obesegrad i tre Vincennesstarter förra vintern och var först i mål även i återkomsten på kolstybben i slutet av oktober, men blev diskvalificerad för träning som måletta. Nu jagas revansch i ett montélopp med 15.750 euro i förstapris och Mathieu Mottier sitter i sadeln.</p>



<p class="wp-block-paragraph">Daniel Wäjerstens fransos <strong>King of the World</strong> (e. Face Time Bourbon) vann i återkomsten på fransk mark i Lyon så sent som i fredags tillsammans med Nicolas Bazire. Samme Bazire sitter i vagnen i ett sexåringslopp med 9.450 euro till vinnaren.</p>



<p class="wp-block-paragraph">Flest blågula intressen finns i Prix de PMU Le Maintenon (€32.000) över 2.850 meter med 14.400 euro i förstapris. David Persson startar <strong>Kash Keeper</strong> (e. Uncle Lasse), som varit etta-etta-trea i sina tre starter på fransk mark i höst. Matieu Mottier kör.<br>Bland motståndarna finns en svenskfödd duo från Erik Bondos stall: <strong>Toscana Southwind</strong> (e. Bold Eagle) och <strong>Imperatur Am</strong> (e. Ready Cash). Den sistnämnde fick en fullträff i tredje försöket i Frankrike när han segrade på 1.10,7/2.500 meter i Lyon för drygt två veckor sedan.</p>



<p class="wp-block-paragraph">Marie Norbergs duon är stona <strong>Justess Viking</strong> (e. Ubriaco), som körs av sonen Lucas i ett amatörlopp, och <strong>Lady d’Elfe</strong> (e. Bon Copain) i en femåringsfinal med 18.000 euro till vinnaren.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-11-18/7616" target="_blank" rel="noopener">Här är startlistorna till Mauquencys 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/2025/11/skarmavbild20251130kl.15.27.03-617x356.jpg" alt="" class="wp-image-798714"/><figcaption class="wp-element-caption">Jingle du Pont vinner för Nicolas Bazire och vinsten i Grand National du Trot var värd 67.500 euro.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Sista chansen att kvala in till finalen i franska löpningsserien Grand National du Trot (€90.000) sker i eftermiddag i Mauquency. Där avgörs den 13:e och sista etappen i serien som inleddes i början av mars. Finalen körs på Vincennes den 6 december me 150.000 euro i total prissumma.</p>



<p class="wp-block-paragraph">Tio hästar har delat på de tolv första etapperna, där <strong>Kanto Avis</strong> (e. Ready Cash) och <strong>Katchi Quick</strong> (e. Enino du Pommereux) vunnit dubbelt, men ingen tidigare etappvinnare tävlar idag. Däremot dyker fjolårets finalvinnare <strong>Jingle du Pont</strong> (e. Niky) och Nicolas Bazire upp i GNT-försöket i Mauquency.</p>



<p class="wp-block-paragraph"><strong>Startlista Grand National du Trot (€90.000) – etapp 13</strong><br>2.850 meter, Mauquency<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Kemia du Chene</strong> (e. Bird Parker) – Benjamin Rochard</li>



<li><strong>Ileo Pierji</strong> (e. Otello Pierji) – Anthony Barrier</li>



<li><strong>Light My Fire</strong> (e. Ready Cash) – Adrien Guarato</li>



<li><strong>Helios Si</strong> (e. Infant du Bossis) – Sebastien Hardy</li>



<li><strong>Loulou de Mye</strong> (e. Cliff du Pommereux) – Romain Christian Larue</li>



<li><strong>Iguane de Caponet</strong> (e. Hand du Vivier) – Yoann Lebourgeois <br><strong>2.875 meter:</strong></li>



<li><strong>Hamilton du Ham</strong> (e. Rachmaniov Sever) – Christophe Martens</li>



<li><strong>Ialto d’Hertals</strong> (e. Alto de Viette) – Theo Duvaldestin</li>



<li><strong>Isofou du Chene</strong> (e. Un Charme Fou) – Paul Philippe Ploquin</li>



<li><strong>J’Aime de Foot</strong> (e. Boccador de Simm) – Antoine Lherete</li>



<li><strong>Hidalgo des Noes</strong> (e. Opium) – Julien Travers</li>



<li><strong>Jingle du Pont</strong> (e. Niky) – Nicolas Bazire</li>



<li><strong>Ideal du Rocher</strong> (e. Cliff du Pommereux) – Clement Duvaldestin</li>



<li><strong>Hulysse Digeo</strong> (e. Reve de Beylev) – Jean William Hallais <br><strong>2.900 meter:</strong></li>



<li><strong>Justin Bold</strong> (e. Bold Eagle) – Pierre Yves Verva</li>



<li><strong>Jeroboam d’Erable</strong> (e. Prodigious) – David Thomain</li>



<li><strong>Jean Balthazar</strong> (e. Alto de Viette) – Pascal Castel</li>



<li><strong>Ina du Rib</strong> (e. Uhlan du Val) – Jean Luc Claude Dersoir</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/2026/11/summermusicnightsdw-617x333.jpg" alt="" class="wp-image-923104"/><figcaption class="wp-element-caption">Summermusic’night S och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Efter ett knappt år i Daniel Wäjerstens träning lämnade fjolårets tyske Derbyvinnaren <strong>Summermusic’night S</strong> (e. Tactical Landing-Somermusic’ Chapter), 1.10,5ak/1.533.693 kr, Daniel Wäjerstens träningslista i måndags. Ny adress blir Åbytränaren Christoffer Eriksson, skriver Travronden.<br>– Han såg kanonfin ut senast på Bergsåker och det är inte varje dag man får in en häst av den här kalibern som dessutom har bevisad form. Jag kan inte tänka mig att dröjer så länge innan han startar i min regi, säger Christoffer Eriksson till Travronden.</p>



<p class="wp-block-paragraph">Summermusic’night S vann tyska Derbyt (€188.452) under Michel Rothengatters flagg och i december förra året anlände han till Wäjersten. Hos Bergsåkertränaren blev det tolv starter (2-1-0) och cirka en kvarts miljon kronor insprunget.</p>



<p class="wp-block-paragraph">Ägaren FFAV L.L.C-FZ har sedan tidigare fem hästar i träning hos Christoffer Eriksson &#8211; däribland treåriga lillasystern <strong>Swept Away S.</strong> (e. Bar Hopping), 1.12,6ak*/292.675 kr – samt tre hos Per Lennartsson och två i Hans Crebas regi. Dessutom har uppfödaren Patrick Maleitzke tre hästar hos Christoffer Eriksson. </p>



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



<p class="has-drop-cap wp-block-paragraph">7I somras var det för första gången en svenskfödd kallblodshingst som fick betjäna ston i det fria på fjället i Sikkilsdalen när Ingemar Perssons <strong>Järvsö Björn</strong> (e. Järvsöviking) var årets val av hingst. Där betäckte han nio ston.</p>



<p class="wp-block-paragraph">Nästa sommar blir det norskt igen när mångfaldige championhingsten Moe Odins lillebror <strong>Moe Svarten</strong> (e. Åsajerven-Moe Vilja), 1.22,5m/2.515.050 nok, tar plats i Sikkilsdalen. 19-åringen gjorde 120 starter (28-14-13) på tävlingsbanan och har verkat i aveln sedan 2013.<br>Totalt har han fått 82 norska och 15 svenskfödda avkommor, där norska trion <strong>Dale Anne, Pave Sokken</strong> och <strong>Vital Vinter</strong> blivit miljonärer med god marginal. Bäst av de svenskfödda är är <strong>Tåga Prinsen</strong>, som travat ihop 550.808 kronor.</p>



<p class="wp-block-paragraph">Moe Svarten kommer att släppas med stona på fjället den 19 juni nästa sommar.</p>

Fokustema
Sju nyheter vid sju
Läs senare
Kriteriefemma på segerjakt
Välbetalda revanscher på Solvalla. Han vinner mest i Norge och på Bjerke. Hemmatränarens starka siffror. Svenskt i fem franska lopp. Derbyvinnare flyttar till Christoffer.
Detta och mer bland onsdagens nyheter.
Detta och mer bland onsdagens nyheter.












