
<p class="has-drop-cap wp-block-paragraph">1 Idag startar världens största travmeeting. På Vincennes ska 87 tävlingsdagar avverkas mellan den 30 oktober till 28 februari nästa år.</p>



<p class="wp-block-paragraph">Totalt tävlas det om 41.623.000 euro under fyra månader och 56.784 euro snitt/lopp. Antalet löpningar för hästar födda i Europa uppgår till 155, vilket är två färre än förra vintermeetinget. Öppna prismedel uppgår till 16.901.000 euro.</p>



<p class="wp-block-paragraph">Här är alla Grupp I-löpningar under vintermeetinget 2025-2026:</p>



<p class="wp-block-paragraph"><strong>Datum – Lopp</strong></p>



<ul class="wp-block-list">
<li>7 december – <strong>Prix de l’Etoile/Prix Ready Cash</strong> (4 år)</li>



<li>14 december – <strong>Prix Bilibilli </strong>(4 år, monté)</li>



<li>14 december – <strong>Prix Jag de Bellouet </strong>(4 år, monté)</li>



<li>14 december – <strong>Prix de Vincennes</strong> (3 år, monté)</li>



<li>21 december – <strong>Criterium Continental</strong> (4 år)</li>



<li>21 december – <strong>Prix Tenor de Baune</strong> (5 år)</li>



<li>4 januari – <strong>Prix du Calvados</strong> (äldre, monté)</li>



<li>18 januari – <strong>Prix de Cornulier</strong> (äldre, monté)</li>



<li>24 januari – <strong>Prix Ourasi</strong> (3 år)</li>



<li>24 januari – <strong>Prix Bold Eagle</strong> (4 år)</li>



<li>25 januari – <strong>Prix d’Amérique</strong> (äldre)</li>



<li>1 februari – <strong>Prix de I’le-de-France</strong> (äldre, monté)</li>



<li>8 februari – <strong>Prix de France </strong>(äldre)</li>



<li>15 februari – <strong>Criterium des Jeunes</strong> (3 år)</li>



<li>22 februari – <strong>Prix de Paris</strong> (äldre)</li>



<li>28 febuari – <strong>Prix des Centaures</strong> (3-5 år, monté)</li>



<li>28 februari – <strong>Prix de Selection</strong> (3-5 år)</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 En av vintermeetingets mest spännande hästar kommer till start under första tävlingsdagen. Jean-Michel Bazire har länge haft höga tankar om <strong>Jushua Tree</strong> (e. Bold Eagle), men resultatet i år är inte speciellt uppseendeväckande…två lopp och diskad båda gångerna.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/julesthibault3-617x397.jpg" alt="" class="wp-image-456093"/><figcaption class="wp-element-caption">Jushua Tree. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Idag handlar det om Prix des Cevennes (€90.000) över 2.850 meter, men Jushua Tree kommer inte till dukat bord även om han rankas etta i Paris-Turf. Motståndare som <strong>Izoard Vedaquais</strong>, <strong>Josh Power</strong> och <strong>Gaspar d’Angis</strong> är inga dunungar.</p>



<p class="wp-block-paragraph">– Jag gillade Jushua Tree efter hans galopp i Angers. Senaste jobbet på Grosbois var mycket bra och den här gången är han redo. Utan bakskor bör han återgå till sina normala prestationer, säger Jean-Michel Bazire till Paris-Turf.</p>



<p class="wp-block-paragraph"><strong>Prix de Cevennes</strong> (€90.000)<br>6-10 år.<br><em>2.850 meter.</em><br><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Jewelcandle Fac</strong> (e. Prodigious) – Damien Bonne</li>



<li><strong>Iroise de la Noe</strong> (e. Tornado Bello) – Sylvain Dieudonne/Thomas Levesque</li>



<li><strong>Happy Danica</strong> (e. Briac Dark) – Alexis Garandeau</li>



<li><strong>Gendreen</strong> (e. Boccador de Simm) – Alexandre Abrivard/Laurent-Claude Abrivard</li>



<li><strong>Horchestro </strong>(e. Sam Bourbon) – Matthieu Abrivard/Guillaume Huguet</li>



<li><strong>Ino du Lupin</strong> (e. Scipion du Goutier) – Antoine Wiels/Jean-Paul Marmion</li>



<li><strong>Fulton</strong> (e. Royal Dream) – Tristan Ouvrie/Nicolas Bazire</li>



<li><strong>Josh Power </strong>(e. Offshore Dream) – Sebastien Ernault</li>



<li><strong>Gaspar d’Angis</strong> (e. Quaro) – Eric Raffin/Jean-Michel Baudouin</li>



<li><strong>Jushua Tree</strong> (e. Bold Eagle) – Jean-Michel Bazire/Nicolas Bazire</li>



<li><strong>Hokkaido Jiel</strong> (e. Brillantissime) – David Thomain/Jean-Luc Dersoir</li>



<li><strong>Izoard Vedaquais</strong> (e. Bird Parker) – Benjamin Rochard/Philippe Allaire</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/12/prixocollard1-617x362.jpg" alt="" class="wp-image-670365"/><figcaption class="wp-element-caption">Working Class Hero vid en av sina segrar på Vincennes. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3 Totalt blev det 16 svensktränade vinnare under förra vintermeetinget. Bäst av de blågula tränarna var Jörgen Westholm med sex vinnare, fördelat på fyra hästar. <strong>Working Class Hero</strong> (e. Village Mystic) stod för tre av vinsterna, medan <strong>Made of Stars</strong> (e. Super Photo Kosmos), <strong>Cameron </strong>(e. Maharajah) och <strong>Nineponts Lasse</strong> (e. Uncle Lasse) tog en seger vardera.</p>



<p class="wp-block-paragraph">Endast en svensk kusk vann lopp…Daniel Wäjersten guidade <strong>Chitchat </strong>(e. Maharajah) till vinst på kolstybben i Paris. 25 svenskfödda vinnare sågs också på Vincennes och tidigare nämnde Working Class Hero var bäst i klassen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/11/markusbsvedberg2-617x333.jpg" alt="" class="wp-image-236206"/><figcaption class="wp-element-caption">Markus B Svedberg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Och när vintermeetinget drar igång är det bara en svenskfödd travare som selas ut. Från Markus B Svedbergs franska filial startar <strong>Power Doc </strong>(e. Muscle Massive) i Prix de Soulac (€68.000) över 2.700 meter och precis som vid förra vinsten på Vincennes i Prix Algorah (€59.000) sitter Franck Ouvrie i sulkyn.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/vincennes28102025.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/10/vincennes28102025.pdf" target="_blank" rel="noreferrer noopener">Samtliga lopp till dagens tävlingar hittar du här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Daniel Redén och Daniel Wäjersten dominerar i den svenska tränarligan 2025 – precis som duon gjorde förra året där kampen om titeln levde in till de sista dagarna på året.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/03/zaxtoneaadam.jpg" alt="" class="wp-image-693172"/><figcaption class="wp-element-caption">Daniel Wäjersten-tränade Zaxton, här med domarbasen Erik Adielsson i sulkyn. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">När Wäjerstens hemmabana <strong>Bergsåker</strong> (start 18.20) spelar huvudrollen på svensk travmark denna torsdag väntar ett spännande möte mellan två duktiga femåringar från duons stall. Två hästar som dessutom möttes i finalen av Svenskt Travderby förra året!</p>



<p class="wp-block-paragraph">Wäjersten mönstrar <strong>Zaxton</strong> (e. Trixton), som Derbyfinalplatsen till trots nått sina största framgångar inom rikstoton. Redén å sin sida plockar ut <strong>Herakles Zet </strong>(e. Propulsion), som vid sidan om Derbyt slutat fyra i Svenskt Travkriterium och Sprintermästaren, samt varit finalist i Kungapokalen.</p>



<p class="wp-block-paragraph">Medeldistans och startbil är uppgiften ikväll, där Zaxton drog andraspår medan Herakles Zet inleder från spår sex.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 För sju år sedan delade Sten O Janssons <strong>Belker</strong> (e. Scarlet Knight) och Svante Båth-tränade <strong>Bythebook </strong>(e. Googoo Gaagaa) broderligt på segern i Svensk Uppfödningslöpning på Jägersro tillsammans med segerkuskarna Torbjörn Jansson och Örjan Kihlström.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/05/belkerml-617x309.jpg" alt="trav, travsport, sulkysport, startlistor, v75, v86, gs75" class="wp-image-43835"/><figcaption class="wp-element-caption">Belker och Torbjörn Jansson vid en av duons segrar tillsammans. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Vid dagens lunchtrav i <strong>Visby</strong> (första start 12.20) är Belker tillbaka på banan efter fyra månaders tävlingsuppehåll, men det är långt från Uppfödningsloppets status på dagens uppgift. Belker kommer nämligen ut från 60 meters tillägg i P21-loppet med 15.000 kronor i förstapris tillsammans med Victor Rosleff.</p>



<p class="wp-block-paragraph">Belker jagar sin första vinst sedan han vann i förre tränaren Jonas Andreas Ås i Årjäng juli 2023. Totalt har den klassiske vinnaren tagit elva vinster på 68 starter och sprungit in över 3,7 miljoner kronor. På meritlistan finns även dubbla andraplatser på Vincennes i Jean-Michel Bazires regi som sexåring 2022.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/251030.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/10/251030.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/2024/05/10b.w.sture1-617x333.jpg" alt="" class="wp-image-588399"/><figcaption class="wp-element-caption">B.W.Sture vann Speedrace till ägaren Birger Wallströms stora glädje. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Uppfödaren, hästägaren och kallblodsprofilen Birger Wallström har gått bort i en ålder av 67 år.</p>



<p class="wp-block-paragraph">Birger Wallström föddes i Gällivare, långt från närmaste travbana, och flyttade till Stockholm för drygt 40 år sedan och ägde företaget B W Montage, som bytte fönster på fastigheter.</p>



<p class="wp-block-paragraph">I Stockholmsräjongen väcktes travintresset och hans första häst var ett varmblod, men det var med den kalla rasen framgångarna och segrarna kom och det började med kallblodsstoet <strong>Gullan Fax </strong>(e. Järvsöfaks), 1.24,3ak*/584.092 kronor. </p>



<p class="wp-block-paragraph">Gullan Fax notering 1.24,3a/1.640 meter vid segern i Prinsessan Madeleines Pokal i Bollnäs 2004 är fortfarande gällande svenskt rekord för fyraåriga, svenska ston.</p>



<p class="wp-block-paragraph">Gullan Fax lade också grunden till en framgångsrik uppfödning för Birger. Stoet lämnade elva avkommor och bland dessa finns fyra avelsgodkända hingstar</p>



<ul class="wp-block-list">
<li><strong>B.W. Sture</strong> (e. Moe Odin), 1.19,2ak/4.034.776 kr.</li>



<li><strong>B.W. Rune</strong> (e. Tekno Odin), 1.20,0ak/3.070.929 kr</li>



<li><strong>B.W. Gulliver </strong>(e. Lome Kongen), 1.22,7am/1.336.878 kr</li>



<li><strong>B.W. Modde</strong> (e. Moe Odin), 1.22,5k*/1.169.331 kr</li>
</ul>



<p class="wp-block-paragraph">Den sistnämnde har verkat mest och längst i aveln och har över 200 svenskfödda avkommor. Bäst i klassen: Sveriges vinstrikaste sto genom tiderna, <strong>Stjärnblomster.</strong></p>



<p class="wp-block-paragraph">Birgers sista seger som hästägare kom med <strong>B.W. Jackpot </strong>(e. B.W. Modde) i Sleipner Cup-finalen för fyraåringar i juni. Hästen ägde han tillsammans med dottern Erika.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Hønsefoss tingsrätt har dömt Even Westby till ett år och tio månaders fängelse. I rättegången erkände Westby reservationslöst, skriver <a href="https://tgn.no/aktuelt/ma-sone-for-lovbrudd-mens-han-var-toppleder-i-travet/19.31440" data-type="link" data-id="https://tgn.no/aktuelt/ma-sone-for-lovbrudd-mens-han-var-toppleder-i-travet/19.31440" target="_blank" rel="noreferrer noopener">Trav-og Galopp-Nytt </a>i Norge.</p>



<p class="wp-block-paragraph">– Den åtalade har systematiskt underlåtit att deklarera inkomst från sin näringsverksamhet och inte fullgjort sin skyldighet att föra bokföring under en mycket lång tidsperiod, och har därmed undandragit stora mängder skatter och avgifter, säger domaren Johan Kr. Öydegard till Trav-og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Totalt handlar det om 5,6 miljoner och målet härrör den tid Even Westby var vd för Norsk Trav AS, Bjerke Travbane och Biri Travbane.</p>
