
<p class="has-drop-cap wp-block-paragraph">1 Sulkytränaren Philip Burrows, 51 år, har stängts av i tio år för att bland annat  ha injicerat vodka i treåriga stoet <strong>Rakero Rebel</strong> efter ha fångats på film tillsammans med den tidigare sulkystjärnan Matthew Anderson den 8 november ifjol.</p>



<p class="wp-block-paragraph">Filmen visade att Rakero Rebel, som skulle tävla samma eftermiddag i Grupp I-loppet New Zealand Trotting Cup ($140.000) på Addington Raceway, injicerades av Philip Burrows med en substans i hästens hals under tio minuters tid samtidigt som Matthew Anderson höll Rakero Rebel lugn med hjälp av en brems.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/1504668399959-350x198.jpg" alt="" class="wp-image-406257"/></figure>



<p class="wp-block-paragraph">En stund senare dök Philip Burrows upp med slangutrustning och förde upp ett platsrör i hästens ena näsborre.</p>



<p class="wp-block-paragraph">Burrows erkände att han injicerat 30 ml vodka (37,2 procent alkohol) i Rakero Rebel för att lugna hästens nerver och medgav också att han givit hästen milkshake. I Burrows medicinskåp hittades två en-liters-flaskor med vodka.</p>



<p class="wp-block-paragraph"><strong>Fotnot:</strong> Matthew Andersson var å sin sida förbjuden att vistas på en travbana efter ha dömts mot sitt nekande för misshandel (strypning) av en kvinna i sitt hem för några år sedan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/skarmavbild20230201kl.08.18.13-617x277.jpg" alt="" class="wp-image-406258"/><figcaption class="wp-element-caption">Matthew Andersson</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">2 Första månaden är avverkad i Nordamerika för de svenska tränarna i år. Medan en del tränare ligger lågt (läs inga starter) är det några som redan varit ordentligt i farten under januari.</p>



<p class="wp-block-paragraph">Allra bäst har det gått för Per Engblom, vars hästar – såväl travare som passgångare – redan hunnit segerdefilera 16 gånger och sprungit in 193.970 dollar. I fredags tog Engblom den senaste vinsten med en travare när hans danska nyförvärv <a rel="noreferrer noopener" href="https://sulkysport.se/svensk-dubbel-pa-big-m/" target="_blank">C You Again</a> vann på Meadowlands.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/02/wb012723r14.jpg" alt="" class="wp-image-406299"/><figcaption class="wp-element-caption">C You Again vinner för Kasper Fouget på Meadowlands. Foto: Lisa Photo</figcaption></figure>



<h2 class="wp-block-heading">Svensktoppen i Nordamerika</h2>



<p class="wp-block-paragraph"><strong>Namn – Resultat – Prispengar ($)</strong></p>



<ol class="wp-block-list">
<li><strong>Per Engblom</strong> – 61 st: 16-9-10 – $193.970</li>



<li><strong>Anette Lorentzon</strong> – 47 st: 3-7-5 – $71.125</li>



<li><strong>Jenny Bier</strong> – 7 st: 2-0-0 – $12.876</li>



<li><strong>Jenny Melander</strong> – 3 st: 0-1-1 – $5.720</li>



<li><strong>Susanne Kerwood </strong>– 3 st: 0-0-1 – $1.119</li>



<li><strong>Marielle Enberg</strong> – 2 st: 0-0-0 – $391</li>
</ol>



<p class="wp-block-paragraph"><strong>Ej startat 2023:</strong> Michelle Crawford, Jonas Czernyson, Susanne Kovacic, Marcus Melander, Mattias Melander, Åke Svanstedt, Nancy Takter och Lucas Wallin.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Det finns gott om svenskintressen när <strong>Vincennes </strong>(13.50) åter öppnar upp portarna denna torsdageftermiddag efter två tävlingsfria dagar. Tomas Malmqvists danskfödda fyraåriga sto <strong>Holly Go Lightly</strong> (e. Västerbo Prestige) gör sin andra start sedan hon var oplacerad i långa E3-finalen i juli. I comebacken slutade det med en sjätteplats, men till dagens lopp – Prix d&#8217;Issoire (€39.000) – förväntas hon steppa upp och utgöra favoritskaran tillsammans med Eric Raffin.</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 kör åt Tomas Malmqvist. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">I Prix de Feucherolles (€33.000) för femåriga ston startar därtill Pierre Levesques svenskfödda Varenne-dotter <strong>Iliade </strong>och i Prix de Chambery (€51.000) för sexåriga hingstar och valacker syns tre svenskfödda hästar.</p>



<p class="wp-block-paragraph">Jarmo Niskanen plockar ut <strong>Hat Trick</strong> (e. Maharajah), Nicolas Bazire <strong>Hulken Sisu</strong> (e. Readly Express) och Laurent-Claude Abrivard prövar lyckan med <strong>Howdy Quick</strong> (e. Up and Quick).</p>



<p class="wp-block-paragraph">Blågula intressen syns även i <strong>Lyon La Soie</strong> (16.27). Pierre Vercruysse <strong>Gazoline Mearas</strong> (e. Ready Cash) jagar första segern på fransk mark i Prix Parc des Cevennes (€33.000), Jarmo Niskanens <strong>Goutte de Pluie </strong>(e. Brillantissime) kommer ut i Prix Parc du Luberon (€24.000) och så är Björn Goop-tränade <strong>Kamikaze du Campus</strong> (e. Ready Cash) på språng efter andra raka segern i treåringsloppet Prix Parc des Ecrins (€18.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-02-02/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Två ston är snabbaste i världen under 2023 och för ovanlighetens skull hittar vi den häst som travat fortast vid seger i Europa och inte i USA.</p>



<p class="wp-block-paragraph">Fransyskan <strong>Delia du Pommereux </strong>(e. Niky-Noune du Pommereux) är snabbaste med 1.09,8a/2.100 meter och den tiden travade hon vid seger i Prix de Bourgogne (€120.000) på Vincennnes den 1 januari för Pierre-Yves Verva.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/01/prixdebourgogne1-617x396.jpg" alt="" class="wp-image-397062"/><figcaption class="wp-element-caption">Delia du Pommereux (5) tar hem Prix de Bourgogne på årets snabbaste tid. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">På andra sidan Atlanten toppar kanadensiskan <strong>Hp Mama B </strong>(e. Royalty For Life-Winters Jewel) och hon kom hem på 1.10,0a/1.609 meter när hon segrade på Mohawk Raceway den 9 januari för Louis-Philippe Roy.</p>



<p class="wp-block-paragraph">I USA har två valacker – <strong>Hillexotic</strong> (e. Muscle Hill) och <strong>Lexus Kody </strong>(e. Archangel) – vunnit kvallopp på 1.10,3, medan snabbaste noteringen i reguljär löpning står femårige hingsten <strong>Barn Hall </strong>(e. Conway Hall) och fyraåriga stoet <strong>Call Me Dani</strong> (e. Dover Dan) för med tiden 1.10,5.</p>



<p class="wp-block-paragraph">I Sverige är <strong>Marre&#8217;s Dreamboy</strong> (e. Maharajah-Your Dreamgirl) snabbast 2023 och igår vann den sexårige hingsten för sin tränare Jörgen Westholm på Solvalla på 1.11,9a/2.140 meter.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Två svenska banor tävlar idag, där det ligger cirka 850.000 kronor extra i sexrättspotten på V64 efter att det inte blivit någon utdelning på fyra rätt i tisdags.</p>



<p class="wp-block-paragraph">I ett dubbelklasslopp är Oscar Berglund-tränade <strong>Bourne Dominion</strong> (e. Chocolatier) ute efter revansch efter att ha gjort bort sig med galopp i V75 i Östersund för knappt två veckor sedan. Hästen hade hittat stilen och kom med bra prestationer bakom sig innan galoppmissen. Fältets två rikaste hästar är båda ston och inleder med 20 meters tillägg: Jan Ove Olsens <strong>Krakas </strong>(e. Yarrah Boko) och Jan-Olov Persson-tränade <strong>Green Mamba</strong> (e. Algiers Hall), båda med färska starter i rikstoton bakom sig.</p>



<p class="wp-block-paragraph">I årets första treåringslopp på Bergsåker plockar Tomas Pettersson ut <strong>Exposed Sox </strong>(e. Face Time Bourbon), som jagar 20 meter bakom sina jämnåriga konkurrenter. Efter två ”lärostarter” i augusti som tvååring har stoet varit tvåa-etta i årets båda starter.</p>



<p class="wp-block-paragraph">Stoet var den femte dyraste hästen då hon såldes på Åby Yearling &#038; Mixed Sales 2021 när klubban slog på 650.000 kronor.</p>



<p class="wp-block-paragraph">Lunchtävlingarna avgörs på <strong>Mantorptravet</strong> (första start start 12.20), där Helena Egertoft-tränade <strong>Fönix Vang</strong> (e. Varenne) tillsammans med Victor Rosleff ska visa att den strålande vinterformen håller i sig. Tre segrar inom loppet av en månad har Fönix Vang plockat.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/01/230202.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">6 Listan över ”Årets Travare” i Australien har kungjorts och den finaste utmärkelsen gick till Andy Gath-tränade <strong>Majestuoso</strong> (e. Majestic Son-Rosemaryz Luck), vilken är född i Nya Zeeland och tog sin största seger i Great Southern Star ($300.000) och var knappt slagen tvåa i finalen i Inter Dominion ($250.000) efter <strong>Just Believe</strong>. Han var också den vinstrikaste travaren i Australien ifjol med 395.310 australiska dollar, vilket motsvarar drygt 2,9 miljoner kronor.</p>



<h2 class="wp-block-heading">Årets titlar:</h2>



<p class="wp-block-paragraph"><strong>Tvååriga ston:</strong><br><strong>Rockinwithattitude </strong>(e. Aldebaran Eagle) – 14 st: 9-2-1 – $130.000</p>



<p class="wp-block-paragraph"><strong>Tvååriga h/v:</strong><br><strong>The Locomotive</strong> (e. Muscle Mass) – 12 st: 9-1-0 – $198.298</p>



<p class="wp-block-paragraph"><strong>Treåriga ston:</strong><br><strong>Egret </strong>(e. Father Patrick) – 11 st: 5-4-1 – $104.720</p>



<p class="wp-block-paragraph"><strong>Treåriga h/v:</strong><br><strong>Cravache Dor</strong> (e. Orlando Vici) – 13 st: 10-2-0 – $178.850</p>



<p class="wp-block-paragraph"><strong>Äldre ston:</strong><br><strong>Queen Elida</strong> (5 år e. Love You) – 12 st: 7-3-2 – $160.340</p>



<p class="wp-block-paragraph"><strong>Äldre h/v:<br>Majestuoso</strong> (v 7 år e. Majestic Son) – 15 st: 7-2-4 – $395.310</p>



<p class="wp-block-paragraph"><strong>Årets Travare:<br>Majestuoso</strong> (v 7 år e. Majestic Son) – 15 st: 7-2-4 – $395.310</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Årets första föl har sett dagens ljus på Haras de Sou i Frankrike. På Hans ”Global” Neléns franska stuteri har <strong>Zeeland Kronos </strong>(e. Muscle Hill-Occasion Kronos), 1.11,6ak*/623.500 kr, blivit mor till en dotter efter Face Time Bourbon för andra året i rad.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/02/skarmavbild20230201kl.09.50.08.jpg" alt="" class="wp-image-406306"/><figcaption class="wp-element-caption">Zeeland Kronos med sin dotter efter Face Time Bourbon. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Zeeland Kronos är halvsyster med Svampen-tvåan <strong>Cool Kronos </strong>(e. Readly Express), 1.10,2ak/947.500 kr. Mormor <strong>Occasion Kronos</strong> (e. Offshore Dream), 1.11,7ak*/641.800 kr. ingår i sin tur i samma syskonskara som <strong>Riff Kronos </strong>(e. Dream Vacation), 1.11,3ak/2.895.567 kr, och <strong>Doctor Doxey Zenz </strong>(e. Donato Hanover), 1.11,7am/1.959.100 kr.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/sorelladivivid-350x420.jpg" alt="" class="wp-image-406335"/><figcaption class="wp-element-caption">Temple Blue med dottern efter Calgary Games. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Vi kan också meddela att storstjärnan <strong>Vivid Wise As</strong> (e. Yankee Glide), 1.08,6<em>/</em>€2.529.788, har fått en lillasyster i Italien. Modern <strong>Temple Blue Chip</strong> (e. Cantab Hall), 1.12,8/$38.295, har nedkommit med ett sto efter Calgary Games.</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
