<p><span class="anfang">B</span>ergsåker står som värd för veckans V75-omgång och det är en riktigt rolig sådan. Diamantstoet har placerats utanför kupongen och istället är det dubbla kallblodslopp på menyn.<br />
Comebackande Månprinsen A.M. (V75-2) kommer med rätta bli storfavorit i sitt lopp medan det andra loppet är vidöppet och kan visa sig vara väldigt streckkrävande.</p>
<div class="factbox right ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									BANFAKTA BERGSÅKER								</h3>
<div class="content">
								<strong>Längd: </strong>1000 m<br />
<strong>Bredd:</strong> 21,5 m (2.140 m), 21,0 m (1.640 m)<br />
<strong>Upplopp:</strong> 200 m<br />
<strong>Open stretch: </strong>Nej<br />
<strong>Vinklad startbilsvinge: </strong>Nej							</div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
<p>I Gulddivisionen kan hemmastjärnan <strong>Esprit Sisu</strong> (V75-3) mycket väl visa sig vara lösningen. Daniel Wäjerstens häst har fått ett lopp i kroppen vilket han sprang på skor. Till lördagens lopp tycks Wäjersten vara inne på att rycka alla skorna vilket var just den balans hästen tävlade på i höstas när han täljde guld och bland annat vann STL Open.<br />
Klass II-försöket är en riktig godbit då det kryllar av hästarna som har massor av ettor i resultatraden. Vi kan inte blunda för det intryck <strong>Denali Doc</strong> (V75-4) gett, men det kommer inte finnas något som helst utrymme för minsta nivåsänkning i den här konkurrensen!</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2022/03/02v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till tävlingarna på Bergsåker.</a></p>
<h2>Avd 1 – Silverdivisionen, 2.140 meter voltstart</h2>
<p>För ovanlighetens skull är det voltstart i näst högsta klassen och som lök på laxen startar två av loppets troliga favoriter från snäva startspår. <strong>Algot Zonett</strong> presterade starkt i den här klassen i höstas och står nära nog på öret perfekt inne i detta lopp. Det handlar om årsdebut, men Daniel Wäjersten har knappast fuskat med träningen och Algot Zonett övertygade stort efter tre månaders paus när han återkom och vann direkt i september. <strong>Van Gogh Z.S.</strong> klarade snävt startspår i Eskilstuna i höstas. Han kommer från en spetstriumf och känns extra effekt från den positionen. <strong>Dwayne Zet</strong> fick drygt halvmiljonen på sig på ett bräde när han vann Sylvesterloppet. Han gjorde nyligen comeback i ett snabblopp hemma i Östersund där stilen lämnade en del övrigt att önska i slutkurvan, men han kom tillbaka fint över spurtrakan. Om vi inte missminner oss var det något utrustningsknas som spökade. <strong>Hector Sisu</strong> såg strålande ut i årsdebuten i Umeå och är anmäld barfota runt om denna gång. <strong>Xanthis Coktail</strong> spurtade bra på avstånd i lördags och är på väg att växa in i den här klassen på allvar.</p>
<h2>Avd 2 – Kallblodsdivisionen, 2.140 meter autostart</h2>
<p><strong>Månlykke A.M.</strong> gör efterlängtad årsdebut och vi minns mycket väl hur bra han såg ut vid fjolårets dito i Gävle. Gunnar Melanders nu åttaårige hingst utvecklade sin startsnabbhet väldigt fint under fjolåret och tar han inte ledningen av egen kraft denna gång ska det vara bra chans att han får överta ledningen i tidigt skede. Det mesta talar för att han vinner direkt nu när <strong>Bellfaks</strong> som enda häst i fältet har lottats till bakspår.</p>
<h2>Avd 3 – Gulddivisionen, 2.140 meter autostart</h2>
<p><strong>Esprit Sisu</strong> slog det kanske inga gnistor om i årsdebuten, men det var inte heller vad vi hade förväntat oss när han kom ut på skor och först fick springa av sig sista 300 meterna. Det var mot det här loppet som Daniel Wäjersten med all önskvärd tydlighet hade tagit sikte och nu kommer också skorycket på alla fyra hovar. <strong>Disco Volante</strong> spetsade i lördags, släppte till vinnaren Stoletheshow och hakade på berömvärt trots att det såg segt ut i slutkurvan. Frågan är om Ulf Ohlsson tyckte att han fick så pass positivt svar från hästen att han vill testa i tät nu istället eller om han vill ge hästen ytterligare något moralhöjande rygglopp. <strong>Born Unicorn</strong> fick ingen utdelning i höstens guldlopp som var Svenskt Mästerskap samt C.L.Müllers Memorial. Den här konkurrensen är enklare, men han är väldigt svårbedömd i sin årsdebut. <strong>Super Schissel</strong> hakade på bra längs sargen i årsdebuten där vi faktiskt streckade honom trots stentuff konkurrens. Den här hästen är bra, men det är däremot inte lördagens utgångsläge&#8230;</p>
<h2>Avd 4 – Klass II, 1.640 meter autostart</h2>
<p>Ett vansinnigt roligt försök i lägsta klassen där det kryllar av ettor i resultatraderna på hästarna. Det lär vara en och annan kusk som åker ut med tro om att de sitter bakom bästa hästen och det kan bli körning därefter. Som <strong>Denali Doc</strong> sett ut vid sina segrar så kan vi dock inte gå ifrån henne som grundtips. Hon sprang 1.11,5 sista varvet i Örebro och stod pall från tät senast på Solvalla trots att hon fick en het häst på utsidan och fick varva på 1.12,5. <strong>Parveny</strong> bröt ut under attack vid Klass II-starten på just Bergsåker i februari och tappade såväl fart som mark i det skedet. Han fick chansen för sent i genrepet på Romme bakom <strong>First Tartar</strong> och det ska bli riktigt kul att se honom från innerspår, med Örjan Kihlström i vagnen samt på balansen barfota fram. <strong>L.A.Boko</strong> visade kunnande redan ifjol hos André Eklundh och har inlett sin tid hos Daniel Wäjersten med två övertygande triumfer. Senast fick han göra jobbet själv i tredjespår sista 700 meterna, men antog den utmaningen och var bara bäst. <strong>Firefoot</strong> övertygade från dödens senast i Östersund och <strong>Bonus Vendil</strong> stod för en stark långspurt vid segern i Gävle i torsdags. Som sagt; ett riktigt fräsigt lopp och det är långt ifrån säkert att vi ens nämnt den hästen som står som vinnare i slutänden.</p>
<h2>Avd 5 – Kallblodslopp, 2.140 meter autostart</h2>
<p>Ett lurigt kallblodslopp där det spontant känns som många om budet. <strong>Ängsbrage</strong> har övertygat vid segrarna som finns i resultatraden och har framförallt en sylvass speed att tillgå om han får tagga upp i ryggar in i det längsta. Han står därtill perfekt inne på pengarna och kan vara svaret på den här gåtan. <strong>S.K.&#8217;s Ariel</strong> var tvåa bakom just Ängsbrage i Bollnäs efter att gått i spåren sista 600 meterna. <strong>Fantomet</strong> styrde Örjan Kihlström in till en mersmakande tredjeplats när de fick bekanta sig med varandra på Åby i februari. Det känns positivt att han fått känna på den här sexåringen och skaffat sig en lite tydligare bild om vad som finns i honom för springa kan hästen tveklöst göra. <strong>Wolt</strong> vann ett uttagningslopp till Norskt Travderby ifjol, men fick strykas i finalen. Han galopperade halvvägs in i loppet i comebacken på Bergsåker, men kan mått gott av den ögonöppnaren. Som sagt; här är det många om budet och det här loppet kommer bli ett gissel att ranka upp under veckan då det inte känns som så mycket skiljer hästarna vid en första anblick.</p>
<h2>Avd 6 – Klass I, 2.140 meter autostart</h2>
<p><strong>Icon Mearas</strong> gick helt okej i Kalmar utan att glänsa. Han fick lägga en speed initialt och hade därtill startat lördagen innan där han fick gå ganska fort mellan två galopper. Det kan ha varit så att det satt lite i benen och vi tycker den här uppgiften ser lämplig ut då han har spetschans från innersniffen. <strong>Hefner Am</strong> galopperade i segerstriden 20 meter före mål mot Bitcoind&#8217; Arc i Gävle. Han fick ett småtufft upplägg i comebacken senast på Bergsåker och höll okej som trea. Det är rimligt att han ska gå framåt med det loppet i kroppen. <strong>No Limit Express</strong> vann i genrepet och är anmäld barfota runt om vilket i sådana fall blir första gången någonsin. <strong>Midleton</strong> övertygade vid dödensvinsten senast på Solvalla och har visat att han kan leverera såväl med som utan skor. <strong>O.K.Nalan</strong> var heroisk i comebackloppet i Boden. Hästen slutade trea i den här klassen på Solänget i oktober och körs nu av Örjan Kihlström för första gången. <strong>Strong Vacation</strong> fortsätter få dåliga utgångslägen på svensk mark, men har visat att det inte saknas kunnande för att likväl prestera på en hög nivå.</p>
<h2>Avd 7 – Bronsdivisionen, 2.640 meter autostart</h2>
<p>Helkul avslutning över två och ett halvt varv. I synnerhet när <strong>Perpetuate</strong> som känns som en potentiell klassklättrare var svårbedömd i årsdebuten. Han fick lägga en viss speed ut på slutrundan, men det syntes redan vid upploppets början att det inte skulle gå vägen. Det kan helt enkelt varit så att han behövde lopp i kroppen och kommer ta stora steg på formtrappan till detta lopp. <strong>Bugatti Miles</strong> avslutade fjolåret med att vinna en Klass I-final på övertygande vis. Nu gör han årsdebut och kan ha mått gott av att fått någon bonusvecka med träning kontra de Redén-hästar vi sett varit ute tidigare som sett aningen, aningen tunga ut i kroppen. <strong>Harper Seabrook</strong> var strålande bra vid dödenssegern senast på Solvalla och har en väldigt hög högstanivå. Sandra Erikssons segermaskin<strong> Gazoline Mearas</strong> ströks på grund av sårskada i Skellefteå den 1 mars och nu blir det sju veckor mellan starterna. Han är anmäld såväl barfota runt om som med jänkarvagn; en kombination med vilken han aldrig tidigare startat i just Erikssons regi. <strong>Marre&#8217;s Dreamboy</strong> råkade inte bara vara finalist i Derbyt samt Europaderbyt i höstas utan detta är en riktigt bra häst som gör spännande årsdebut.</p>
